python学习笔记02： 数据类型

Python基本数据类型一般分为：字符串类型string、整数类型int、浮点类型float、列表list、字典dic、元祖tuple、集合set、布尔类型bool

1.字符串类型str

1）字符串格式化

 1 name = '小小兔'
 2 time = '2020/04/18'
 3 
 4 # 方法一：字符串连接（最简单，不推荐使用），用“+”连接，直接把输出的字符串和变量连接起来。
 5 s1 = '欢迎'+name+'登录，今天的时间是'+time#在内存里面存5个变量（name，time，欢迎，登录今天的时间，s1）
 6 print(s1)
 7 
 8 # 方法二：占位符连接字符串（推荐使用），多个变量后面跟值必须加括号
 9 s2 = '欢迎%s登录，今天的时间是%s' % (name, time)#在内存里存3个变量（name，time，s2）
10 print(s2)
11 s3 = '欢迎%s登录' % name
12 print(s3)
13 
14 # 占位符有常用的有三种：
15 # %s：字符串，后面跟什么类型都可以
16 # %d：整数型，后面必须跟整数型
17 # %f：浮点型，后面必须跟小数型，默认保留6位小数，例 %.2f 保留2位小数
18 age = 18
19 score = 98.8888888
20 s4 = '年龄是%d,分数是%.2f' % (age, score)
21 s5 = '年龄是%s,分数是%s' % (age, score)
22 print(s4)
23 print(s5)
24 
25 # 方法三：使用{}（和%s一样，用{}占位，参数多，容易弄混）
26 s6 = '年龄是{}，分数是{}'.format(age, score)
27 print(s6)
28 
29 # 方法四：使用{}和format,适用于参数多，不需要按照顺序来
30 s7 = '欢迎{name}登录，今天的时间是{time}'.format(time='2020/04/18', name='小小兔')
31 print(s7)

打印结果如下：               

1. 欢迎小小兔登录，今天的时间是2020/04/18
2. 欢迎小小兔登录，今天的时间是2020/04/18
3. 欢迎小小兔登录
4. 年龄是18,分数是98.89
5. 年龄是18,分数是98.8888888
6. 年龄是18，分数是98.8888888
7. 欢迎小小兔登录，今天的时间是2020/04/18

注意：

            参数多，使用占位符不容易一一对应，容易弄错顺序，如果使用{}方式可以不需要按照顺序来，比较直观

2）字符串常用方法

 1 s = 'hahaha'
 2 print(s[1])  #字符串有下标，根据下标取值
 3 # for i in s:  #字符串可以循环(因为有下标)
 4 #     print(i)
 5 
 6 print(s.count('a'))  #找某个元素出现的次数
 7 
 8 print(s.find('a'))  #找某个元素的下标
 9 
10 print(s.isdigit())  #判断是否为纯数字，若是纯数字返回True，否返回False
11 
12 print(s.startswith('h'))  #判断字符串是否以什么开头，若是返回True，否返回False
13 print(s.endswith('com'))  #判断字符串是否以什么结尾，若是返回True，否返回False
14 
15 print(s.lower())  #字符串全部变成小写，
16 print(s.upper())  #字符串全部变成大写
17 
18 s1 = '   hahaha   \n'
19 s2 = 'hahaha,'
20 print(s1.strip())  #默认去掉字符串两边的空格和换行符\n
21 print(s2.strip(','))  #指定逗号，可以去掉逗号的字符串
22 
23 print(s.replace('a', '1'))  #替换字符串
24 print(s.replace('a', '2', 1))  #指定1，替换第1次出现的
25 s3 = '123  123'
26 print(s3.replace(' ', ''))  #去掉字符串中间的空格
27 
28 s4 = 'zyb,cmc,wy,lj,lxy'
29 s5 = 'zyb cmc wy   lj  lxy'
30 s6 = 'zyb.cmc.sy'
31 print(s4.split(','))  #指定逗号，按逗号分割字符串，把分割的字符串放到list里['zyb','cmc','wy','l']
32 print(s5.split())  #默认以空格进行分割
33 print(s6.split(','))  #若分割符号填写错误，把原始字符串直接放到list里面
34 
35 l1 = ['zyb', 'cmc', 'wy', 'lj', 'lxy']
36 print(','.join(l1))  #把list每个元素通过逗号连接起来变成字符串
37 
38 
39 print(s.index('a'))  #找某个元素的第一次出现的下标
40 print(s.index('a',2))  #指定2，从下标2开始找
41 # find和index区别：找不存在的元素，index找不到会报错，find找不到会返回-1，不会报错
42 
43 print(s.islower())  #判断字符串是否全部小写
44 print(s.isupper())  #判断字符串是否全部大写
45 
46 #001,002,003,004.....
47 s7 = '5'
48 print(s7.zfill(3))  #补零，传值3，不够3位的补零
49 
50 print(s.capitalize())  #首字母大写
51 
52 s8 = '欢迎光临'
53 print(s8.center(50, '*'))  #输出时居中字符串，长度不够50的用*补齐
54 
55 s9 = '   '
56 print(s9.isspace())  #判断字符串是否为空格，若是空格返回True，否则返回False
57 
58 print(s.isalnum())  #如果是大小写字母、汉字、数字返回True，其他的字符串都返回False
59 print(s.isalpha())  #如果是大小写字母、汉字返回True，其他的字符串都返回False
60 
61 s10 = '编号是{name},{age}'
62 print(s10.format(name=1, age=2))  #字符串格式化,直接传值
63 print(s10.format_map({'name': 1, 'age': 35}))  #字符串格式化使用，必须传字典
64 
65 print(s1.lstrip())  #只去掉前面的空格
66 print(s1.rstrip())  #只去掉后面的空格

打印结果如下：

1. a
2. 3
3. 1
4. False
5. True
6. False
7. hahaha
8. HAHAHA
9. hahaha
10. hahaha
11. h1h1h1
12. h2haha
13. 123123
14. ['zyb', 'cmc', 'wy', 'lj', 'lxy']
15. ['zyb', 'cmc', 'wy', 'lj', 'lxy']
16. ['zyb.cmc.sy']
17. zyb,cmc,wy,lj,lxy
18. 1
19. 3
20. True
21. False
22. 005
23. Hahaha
24. ***********************欢迎光临***********************
25. True
26. True
27. True
28. 编号是1,2
29. 编号是1,35
30. hahaha

31.    hahaha

2.列表list

1）列表常用方法

 1 s = '王一，王二，王三，王四'  #定义字符串，字符串有下标，但无法取其中的某个值
 2 l2 = ['王一', '王二', '王三', '王四']  #定义列表，根据索引可以从中取某个值，下标从0开始计数
 3 # 索引/下标0      1     2      3
 4 l3 = []  #定义空列表
 5 
 6 #增
 7 l2.append('小小兔')  #append增加到最后
 8 print(l2)
 9 l2.insert(1, '小小月')  #insert增加指定位置，1代表下标
10 print(l2)
11 
12 #删
13 l2.pop(1)  #不传下标默认删除最后一个值，传入下标删除指定位置
14 print(l2)
15 del l2[2]  #删除指定位置的值
16 print(l2)
17 l2.remove('王一')  #删除指定的值（删除不存在元素会报错）
18 print(l2)
19 l2.clear()  #清空列表
20 print(l2)
21 
22 #改
23 l2[0] = '王一一'  #修改指定位置的值
24 print(l2)
25 
26 #查
27 print(l2[0])  #获取指定元素，[-1]代表最后一个元素
28 
29 l4 = [1, 54, 77, 2, 3, 54, 4]
30 #其他方法
31 print(l4.count(54))  #某个元素出现的次数
32 print(l4.index(2))  #取索引（找不存在的元素，报错）
33 #.sort()先排序再打印，如果打印print(l4.sort()),则输出结果为None
34 l4.sort()  #升序
35 print(l4)
36 l4.sort(reverse=True)  #降序
37 print(l4)
38 l5 = l4.copy()  #复制
39 print(l5)
40 l4.extend(l2)  #扩展列表，把l2的值加到l3里
41 print(l4)
42 l4.reverse()  #反转数组
43 print(l4)
44 
45 #二维数组的取值：
46 infos = [
47     ['小黑', '1111', '北京'],
48     ['小贝', '2222', '上海'],
49     ['小明', '3333', '广州']
50 ]
51 print(infos[-1][0])
52 
53 list1 = [1, 2, 3, 4]  #一个普通的数组
54 list2 = ['marry', 'lily', [50, 'monkey']]  #二维数组
55 list3 = ['name', 'sex', ['lily', 124, ['aaa', 'bb']]]  #三维数组
56 
57 l = [
58     [[1,2,3],['abc','456']],
59     'xiaohei',
60     {'name':'xiaobai'}
61 ]
62 print(l[2]['name'])

打印结果如下：

1. ['王一', '王二', '王三', '王四', '小小兔']
2. ['王一', '小小月', '王二', '王三', '王四']
3. ['王一', '王三', '王四']
4. ['王一', '王二', '王四']
5. ['王二', '王三', '王四']
6. []
7. ['王一一', '王二', '王三', '王四']
8. 王一
9. 2
10. 3
11. [1, 2, 3, 4, 54, 54, 77]
12. [77, 54, 54, 4, 3, 2, 1]
13. [77, 54, 54, 4, 3, 2, 1]
14. [77, 54, 54, 4, 3, 2, 1, '王一', '王二', '王三', '王四']
15. [4, 54, 3, 2, 77, 54, 1]
16. 小明
17. xiaobai

2）切片

切片是list取值的一种方式，可以范围取值（取多个元素），可以理解为，从第几个元素开始，到第几个元素结束。

切片是不包含后面那个元素的值的（顾头不顾尾）。

切片后面还有可以写一个参数，叫做步长，也就是隔多少个元素，取一次，默认可以不写，也就是隔一个取一次。

切片操作也可以对字符串使用，和列表的用法一样。

 1 l = [1,2,3,4,5,6,7,8,9,10] 
 2 print(l[0:5])  #切片：顾头不顾尾
 3 print(l[:5])  #冒号前面省略，默认是0
 4 print(l[5:])  #冒号后面省略，默认取到尾
 5 print(l[:])  #两边都不写，默认取所有
 6 print(l[1:5:2])  #从第2个元素开始，到第5个结束，隔一个取一个
 7 print(l[::2])  #从头到尾，隔一个取一个
 8 print(l[::-1])  #若步长为负数，就是从后往前取值
 9 print(l[-1:-11:-1])  #若步长为负数，前面指定范围用的下标也得写负数
10 
11 t = ('a', 'b', 'c')
12 print(t[1:3])  #元祖可以通过下标方式取值
13 
14 s = 'abcdefg'
15 print(s[1:3])  #字符串也可以通过下标方式取值

打印结果如下：

1. [1, 2, 3, 4, 5]
2. [1, 2, 3, 4, 5]
3. [6, 7, 8, 9, 10]
4. [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
5. [2, 4]
6. [1, 3, 5, 7, 9]
7. [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
8. [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
9. ('b', 'c')
10. bc

列表小练习：

 1 # 欢迎xxx登录，今天的时间是xxx。登录错误次数过多，最多登录3次
 2 # 分析
 3 # 1、循环3次
 4 # 2、输入账号，判断账号是否存在（in  或  count）
 5 # 3、根据账号取到下标，然后根据账号的下标取到对应的密码（index）
 6 # 4、输入密码，判断密码是否正确
 7 # 5、若账号和密码正确，登录成功，立即结束循环（break）
 8 
 9 import datetime
10 today = datetime.datetime.today()
11 usernames = ['小黑', '小贝', '小白']
12 passwords = ['123456', '1111', '1']
13 for i in range(3):
14     username = input('输入username：')
15     if usernames.count(username) > 0:
16         index = usernames.index(username)
17         password = passwords[index]
18         pwd = input('输入password：')
19         if password == pwd:
20             print('欢迎【%s】登录，今天的时间是%s' % (username, today))
21             break
22         else:
23             print('密码错误')
24     else:
25         print('账号不存在')
26 else:
27     print('登录错误次数超过3次')

3.字典dic

字典具有极快的查找速度；字典是一种key-value的数据类型，比如说要存每个人的信息，那么每个人的编号就是key，value就是每个人的信息，这样的话，一个字典就能存所有人的信息了。字典的定义使用{}，每个值用“，”隔开，key和value使用“：”分隔。字典是无序的，因为它没有下标，用key来当索引，所以是无序的。字典的key必须是唯一的，因为它是通过key来进行索引的，所以key不能重复。

 1 stu_info = {
 2     'name': '小黑',
 3     'phone': '1111',
 4     'addr': '北京'
 5 }
 6 
 7 # 增
 8 stu_info['age'] = 18  #新增   dic[key]=value
 9 stu_info.setdefault('qq', '1234567')  #新增  dic.setdefault(key,value)
10 print(stu_info)
11 # []和setdefault的区别：key存在，[]会替换values，setdefault不做修改。key不存在的时候没区别。
12 
13 # 删
14 stu_info.pop('phone')  #删除（不存在的key，报错）  dic.pop(key)
15 del stu_info['name']  #删除  del dic[key]
16 print(stu_info)
17 
18 # 改
19 stu_info['name'] = '小强'  #修改（key存在，就是修改；key不存在，就是新增）  dic[key]=value
20 print(stu_info)
21 
22 # 查
23 print(stu_info.get('name'))  #查询（key不存的时候，get取值none）  dic.get(key)
24 print(stu_info.get('qq', '不存在'))  #get不到值，默认值返回值
25 print(stu_info['phone'])  #查询（key不存的时候，[]报错）
26 
27 
28 # 其他方法
29 new_stu_info = stu_info.copy()  #复制
30 stu_info.clear()  #清空字典
31 print(stu_info.keys())  #打印字典所有的key
32 print(stu_info.values())  #打印字典所有的values
33 print(stu_info.items())  #字典转换成list
34 stu_info.update(qq='890344')  #更新字典值，key存在就更新，key不存在就添加
35 print(stu_info)

打印结果如下：

1. {'name': '小黑', 'phone': '1111', 'addr': '北京', 'age': 18, 'qq': '1234567'}
2. { 'addr': '北京'}
3. {'name': '小强', 'phone': '1111', 'addr': '北京'}
4. 小黑
5. 不存在
6. 1111
7. dict_keys(['name', 'phone', 'addr'])
8. dict_values(['小黑', '1111', '北京'])
9. dict_items([('name', '小黑'), ('phone', '1111'), ('addr', '北京')])
10. {'name': '小黑', 'phone': '1111', 'addr': '北京', 'qq': '890344'}

4.元祖tuple

 1 t = (1, 2, 2, 3, 2)  #元祖是数组的一种，与list的区别：一旦创建，不能修改，没有增删改
 2 print(t[0])  #元祖可以取值
 3 print(t[-1])
 4 l = ('ip',3306,'user','password')  #如连接数据库，不可以修改，就可以定义成元祖
 5 
 6 for i in t:#元祖可以循环
 7     print(i)
 8 
 9 # 其他方法：
10 print(t.index(3))  #找某个元素的下标
11 print(t.count(2))  #找某个元素出现的次数
12 
13 t1 = (2)
14 print(type(t1))
15 t2 = ('zss')
16 print(type(t2))
17 t3 = ('ss',)  #如果元祖只有一个元素，后面加个逗号，才会认为是元祖
18 print(type(t3))

 打印结果如下：

1
2

1
2
2
3
2

5.集合set

 1 s = {1, 2, 3, 4, 5, 5, 6, 7}#定义集合
 2 print(s)#1.集合天生去重;2.集合是无序的
 3 
 4 s2 = set()#空集合
 5 s3 = {}#空字典
 6 
 7 for i in s:#集合可以循环
 8     print(i)
 9 
10 l = [1, 2, 3, 4, 5, 5, 6, 7]
11 l = list(set(l))#list去重：list先转成set去重后在转成list
12 print(l)
13 
14 
15 s.add(8)#添加元素
16 print(s)
17 s.update({9, 5, 6})#把另外一个集合加到这个集合里面
18 print(s)
19 s.remove(4)#删除指定元素
20 print(s)
21 
22 #关系测试（交际，并集，差集，对称差集）
23 l1 = [1, 2, 3, 4]
24 l2 = [2, 3, 4, 5]
25 l1 = set(l1)
26 l2 = set(l2)
27 # 取交集：就是两个集合里面相同的元素
28 print(l1 & l2)#取交集
29 print(l1.intersection(l2))#取交集
30 
31 # 取并集：就是把两个集合合并到一起
32 print(l1 | l2)#取并集
33 print(l1.union(l2))#取并集
34 
35 # 取差集:在a集合里面存在，在b集合里面不存在的
36 print(l1 - l2)#取差集
37 print(l1.difference(l2))#取差集
38 
39 # 取对称差集:把a集合和b集合里面相同的元素去掉，剩下的
40 print(l1 ^ l2)#取对称差集
41 print(l1.symmetric_difference(l2))#取对称差集
42 
43 
44 l3 = {1, 2, 3, 4, 5, 6, 7, 8, 9}
45 l4 = {2, 3, 4, 5}
46 print(l3.issuperset(l4))#判断a集合是不是b集合的父集
47 print(l4.issubset(l3))#判断a集合是不是b集合的子集

6.布尔类型bool

对于布尔值，只有两种结果即True和False

7.作业

 1 # 1、注册
 2 # usernames=['小黑','小贝','小白']
 3 # passwords=['123456','1111','1']
 4 # 需要把上面的2个list先转成字典；最多输入3次机会，输入账号（校验账号是否存在，若存在，不能注册；校验是否为空，空格也算空，为空也算一次错误）；输入密码和确认密码（校验两次密码是否一致，若一致，加到字典中，注册成功；校验输入是否为空）。
 5 
 6 # 分析：
 7 # 1）两个list转成字典，需要循环，username是key，password是value
 8 # 2）循环3次，输入账号，校验是否为空，若不为空，继续
 9 # 3）判断账号是否在字典里面，若不在，继续
10 # 4）输入密码和确认密码，校验是否为空，若不为空，继续
11 # 5）判断两次输入密码是否一致，若一致，注册成功
12 # 6）账号和密码加入到字典里面
13 
14 usernames = ['小黑', '小贝', '小白']
15 passwords = ['123', '111', '222']
16 d = {}
17 for i in range(len(usernames)):#列表转换成字典
18     u = usernames[i]
19     p = passwords[i]
20     d[u] = p
21 print(d)
22 for i in range(3):
23     user_name = input('请输入账号：').strip()#去掉空格
24     if user_name in d:
25         print('用户名已存在')
26     elif user_name == '':
27         print('用户名不能为空')
28     else:
29         pwd1 = input('请输入密码：').strip()
30         pwd2 = input('再次确认密码：').strip()
31         if pwd1 == '' or pwd2 == '':#校验不为空
32             print('密码不能为空')
33         elif pwd1 != pwd2:
34             print('两次输入密码不一致，请重新输入')
35         else:
36             d[user_name] = pwd1
37             print('恭喜{name}注册成功'.format(name=user_name))
38             break
39 else:
40     print('3次机会已用完')
41 print(d)
42 
43 
44 # 2、登录:
45 # usernames=['小黑','小贝','小白']
46 # passwords=['123456','1111','1']
47 # 最多输入3次机会，输入账号（校验账号是否存在，从字典里面判断，若不存在，不能登录）和密码（账号和密码一致才能登录）
48 
49 # 分析：
50 # 1）两个list转成字典，需要循环，username是key，password是value
51 # 2）循环3次，输入账号，判断是否为空，若不为空，继续
52 # 3）判断账号是否存在字典里面，若存在，继续 not in
53 # 4）输入密码，判断密码是否为空，若不为空，继续
54 # 5）根据账号从字典里面获取密码，和用户输入的密码作比较，如果一致登录成功
55 
56 usernames = ['小黑', '小贝', '小白']
57 passwords = ['123', '111', '222']
58 d = {}
59 for i in range(len(usernames)):#列表转换成字典
60     u = usernames[i]
61     p = passwords[i]
62     d[u] = p
63 print(d)
64 for i in range(3):
65     user_name = input('请输入账号：').strip()#去掉空格
66     if user_name == '':
67         print('账号不能为空')
68     elif user_name not in d:
69         print('账号不存在')
70     else:
71         pwd1 = input('请输入密码：').strip()
72         if pwd1 == '':#校验不为空
73             print('密码不能为空')
74         elif pwd1 != d.get(user_name):
75             print('密码输入错误')
76         else:
77             print('恭喜{name}登录成功'.format(name=user_name))
78             break
79 else:
80     print('3次机会已用完')