Python基础数据类型与for循环

　　数据类型：int，bool，str，list， tuple元组，dict字典。

　　1.数字：12，3，4

　　在使用print打印数字时，在终端界面中无法判断出打印的是什么类型，当我们需要知道一个值是什么类型的时候，此时可以使用tpye()。

1 #-*- encoding -*-
2
3 print(100, type(100))    #100, <class, int>
4 print('100', type('100'))    #100, <class. str> 

　　2.字符串：str，python凡是由引号引起来的都是字符串，三个引号引起来的内容赋值给一个变量，则是一个大字符串。字符串与字符串可相加（字符串拼接），字符串可与数字相乘。主要用来存储少量数据，进行操作。

1 #-*- encoding:utf-8 -*-
2
3 print('I\'m a teacher')     #字符串中包含引号加\
4
5 print("I'm a teacher")     #字符串中包含引号，外面是双引号

　　2.1 字符串索引与切片

 1 s = 'ABCDLSESRF'
 2 # 索引
 3 s1 = s[0]
 4 print(s1)   # A
 5 # 取ABCD  切片取：顾头不顾尾
 6 s2 = s[0:4]
 7 print(s2)
 8 # 取F
 9 s3 = s[-1]
10 print(s3)
11 # 取A到F
12 s4 = s[0:]  # == s4 = s[:]
13 print(s4)
14
15 s = 'ABCDLSESRF'
16 # 只取ACL  s[首:尾:步长] 步长默认是1
17 s5 = s[0:5:2] # 最后一个2表示步长，从0开始隔1个取一个字符。如果没有最后一个步长，默认是1
18 print(s5)
19 # 取DCBA
20 s6 = s[3::-1]
21 print(s6)
22 # 取DB
23 s7 = s[3::-2]
24 print(s7)
25 # 倒着取完
26 s8 = s[-1::-1]  # == s8 = s[::-1]
27 print(s8)

　　2.2 字符串的操作

　　按照需求对字符串进行操作

 1 # 字符串的操作
 2 s = 'alexWUsir'
 3 # 首字母大写,其余大小
 4 s1 = s.capitalize()
 5 print(s1)
 6
 7 # 全部变为大写
 8 s2 = s.upper()
 9 print(s2)
10
11 # 全部变为小写
12 s3 = s.lower()
13 print(s3)
14
15 # 像在输入验证码的时候，常常提示不区分大小写，此时这些字符串操作方法就能满足需求
16
17 # 大写变小写，小写变大写
18 s4 = s.swapcase()
19 print(s4)
20
21 s = 'alex egon*wusir'
22
23 # 让每个特殊字符（或数字）隔开的字符串首字符大写
24 s5 = s.title()  # 会将字符串内容中的被特殊字符隔开的每个字符串的首字母变为大写
25 print(s5)
26
27 s = 'alexWUsir'
28
29 # 加入宽度后，空隔填充，进行居中
30 s5 = s.center(20)
31 print(s5)
32
33 # 加入宽度后，在加入填充的字符，进行居中
34 s6 = s.center(20, '#')
35 print(s6)
36
37 s = 'al\tsir'
38 # 当出现\t时，包括前面，不够参数长度的补上参数长度
39 s7 = s.expandtabs(4)
40 print(s7)   # al    sir
41
42 # 公共方法，长度
43 s = 'alexWUsir'
44 l = len(s)
45 print(l)

　　2.2 字符串中的方法

 1 # 判断一个字符串以什么为开头，是返回True
 2 s = 'alexWUsir'
 3 s8 = s.startswith('al')
 4 print(s8)   # True
 5
 6 # 判断字符串的第二位到最后是否以e开头
 7 s9 = s.startswith('e', 2)
 8 print(s9)   # True
 9
10 # 判断字符串的第二位到第四位是否以e开头
11 s10 = s.startswith('e', 2, 5)
12 print(s10)  # True
13
14 # 查找字符串中有没有L这个元素
15 s = 'alexWUsir'
16 s11 = s.find('W')  # 返回这个元素对应的索引
17 print(s11)  # 4
18
19 # 查找字符串的第二位到第四位有没有W这个元素
20 s = 'alexWUsir'
21 s12 = s.find('W', 2, 5)
22 print(s12)  # 4
23
24 # 查找字符串的第二位到第四位有没有A这个元素
25 s = 'alexWUsir'
26 s13 = s.find('A', 2, 5)
27 print(s13)  # 找不到返回-1
28
29 # 通过元素找索引,这种方法找不到会报错
30 # s14 = s.index('A')
31 # print(s14)
32
33 # 去除一个字符串的前后空格
34 s = '  alexWUsir  '
35 s15 = s.strip()  # 默认删除前后空格
36 print(s15)   # alexWUsir
37
38 # 去除一个字符串中的%
39 s = 'alexWUsir%'
40 s16 = s.strip('%')
41 print(s16)  # alexWUsir
42
43 # 去除字符串中的*%
44 s = '*alexWUsir%'
45 s17 = s.strip('*%')
46 print(s17)  # alexWUsir
47
48 # 去除字符串中的*%
49 s = '*a%lexWUsir%'
50 s18 = s.strip('*%')
51 print(s18)  # a%lexWUsir
52
53 # rstrip 从右删
54 # lstrip 从左删
55
56 # 字符出现个数
57 s = 'alexaa wusirl'
58 s19 = s.count('a')
59 print(s19)  # 3
60
61 # split 将字符串按照规定的分割。一份为2，作为分割的字符消失。同时也是str转list
62 s = 'alex wusir why'
63 l = s.split()  # 默认以空格分割
64 print(l)  # ['alex', 'wusir', 'why']
65
66 s = ':alex:wusir:why'
67 l1 = s.split(':')  # 以:分割
68 print(l1)  # ['', 'alex', 'wusir', 'why']
69
70 # format的格式化输出.三种玩法，高大上的
71 # format第一种
72 s = '我叫{}, 今年{}, 爱好{}'.format('why', 25, 'python')
73 print(s)   # 我叫why, 今年25, 爱好python
74
75 # format第二种
76 s = '我叫{0}, 今年{1}, 爱好{2}， 我是{0}'.format('why', 25, 'python')
77 print(s)   # 我叫why, 今年25, 爱好python， 我是why
78
79 # format第三种
80 s = '我叫{name}, 今年{age}, 爱好{hobby}， 我是{name}'.format(name = 'why', age = 25, hobby = 'python')
81 print(s)   # 我叫why, 今年25, 爱好python， 我是why
82
83 # 替换
84 s = '老李，老王，老将, 老李'
85 s20 = s.replace('老李', '老大')
86 print(s20)  # 老大，老王，老将, 老大
87
88 s = '老李，老王，老将, 老李'
89 s21 = s.replace('老李', '老大', 1)
90 print(s21)  # 老大，老王，老将, 老李
91
92 name = 'whylinux123'
93 print(name.isalnum())   # 字符串是否由字母或数字组成
94 print(name.isalpha())   # 字符串是否只由字母组成
95 print(name.isdigit())   # 字符串是否只由数字组成
96
97 # 以上操作对原字符串没有影响，都是新生成了一个字符串

　　2.3 补充

　　2.3.1 判断一个字符串中是否含有非法字符，或不含非法字符

1 s = 'fds苍进空adf'
2
3 if '苍井空' in s:
4     print('您的评论存在敏感词汇')
5 s = 'fsdfsdz'
6 if '苍井空' not in s:
7     print('没有非法字符')

　　3.bool：布尔值，Flase，True。

　　没有什么方法，说下数据类型转换。如果将int类型的转换为str，则只需str()将int类型的数字或变量包起来即可，没有要求。如果将str类型的转换为int类型，只需将int()将str类型的字符串或变量包含起来即可，但是有要求，字符串只能是数字字符。

　　数字转换为bool值

1 i = 10
2 j = 0
3 print(bool(i))  # True
4 print(bool(j))  # False

　　bool值转换为数字

1 i = 10
2 j = 0
3 print(bool(i))  # True
4 print(bool(j))  # False

　　字符串与bool值

1 s =''
2 print(bool(s))  #False
3 s = '0'
4 print(bool(s))  #True

1 s = ''
2 if s:
3     pass
4 else:
5     print('空的') #

　　4.int

　　可以在PyCharm中，输入int后，点击Ctrl+鼠标左键，可以跳到class中看有哪些操作方法，这里只记住一个就行，其他有需要了解看class或百度。

　　bit_length()，将int类型的数据转换为二进制，然后返回该数字占用二进制最少的bit位数。

1 # bit_length()方法，将int类型的数据
2 # 转换为二进制用的最少位数
3 # 数字3 0000 0011   所以是2
4 # 数字5 0000 0101   所以是3
5 # 数字1 0000 0001   所以是1
6 i = 3
7 print(i.bit_length()) #3

　　5.list

　　列表，可以存储大量的数据。从数据库取出数据，如果需进行处理，可以从数据库将数据取出到list列表中

　　其他语言中也有类似于列表的数据类型，如js中的数组，他是以[]括起来的，每个元素以逗号隔开，而且他里面可以存放各种数据类型的元素，比如:

　　li = ['alex', 123, True, (1, 2, 3, 4), [1, 2, 3, '小明'], {'name' :  'alex'}]    对象也同样可以放入

　　列表相对于字符串，不仅可以存储不同的数据类型，而且可以存储大量的数据，列表是有序的，有索引值，可切片。有序就证明有索引值，有切片。

1 li = ['alex', [1, 2, 3], 'wusir', 'egon', '女神', 'why']
2
3 print(li[0])    # alex
4 print(li[1])    # [1, 2, 3]
5 print(li[0:3])  # ['alex', [1, 2, 3], 'wusir']
6
7 # 列表的其他操作切片等与字符串一样，因为是有序的，所以有索引值，所以可以切片

　　5.1 列表的操作方法

　

 1 li = ['alex', [1, 2, 3], 'wusir', 'egon', '女神', 'why']
 2
 3 # 增加 append
 4 li.append('xx')
 5 print(li)   # ['alex', [1, 2, 3], 'wusir', 'egon', '女神', 'why', 'xx']
 6
 7 li.append(1)
 8 print(li)   # ['alex', [1, 2, 3], 'wusir', 'egon', '女神', 'why', 'xx', 1]
 9
10 # 增加insert 按照索引位置插入增加
11 li.insert(5, 'yy')
12 print(li)   # ['alex', [1, 2, 3], 'wusir', 'egon', '女神', 'yy', 'why', 'xx', 1]
13
14 # 迭代的增加,迭代：由多个元素组成的对象是可迭代的。增加的是可迭代对象的每个元素，加入到最后
15 li.extend('qq')
16 print(li)   # ['alex', [1, 2, 3], 'wusir', 'egon', '女神', 'yy', 'why', 'xx', 1, 'q', 'q']
17
18 li = ['alex', 'wusir', 'egon', '女神', 'why']
19
20 # 删 pop，类似出栈概念，返回出栈者
21 li.pop()    # 按索引去删除,默认弹出最后一个
22 print(li)
23
24 # 删 remove, 按元素去删，没有返回值
25 li.remove('alex')   # ['wusir', 'egon', '女神']
26 print(li)
27
28 # 清空列表
29 li.clear()
30 print(li)   # []
31
32 # 在内存中将列表删除
33 del li
34 # print(li)   # 报错，li没有定义
35
36
37 li = ['alex', 'wusir', 'egon', '女神', 'why']
38
39 # 切片去删，删除一片
40 del li[0:3]
41 print(li)   # ['女神', 'why']
42
43
44 # 改, 按照索引去改
45 li[1] = '男神'
46 print(li)   # ['女神', '男神']
47
48 li = ['alex', 'wusir', 'egon', '女神', 'why']
49 # 改， 切片去改，切片去改，只能使用可迭代的对象作为赋值的对象
50 li[0:2] = 'python' # 前两位去除后，位置变空，填充赋值的对象的迭代元素
51 print(li)   # ['p', 'y', 't', 'h', 'o', 'n', 'egon', '女神', 'why']
52
53 li = ['alex', 'wusir', 'egon', '女神', 'why']
54 li[0:2] = [1, 2, 4, 'xxx']  # 前两位去除后，位置变空，填充赋值的对象的迭代元素
55 print(li)   # [1, 2, 4, 'xxx', 'egon', '女神', 'why']
56
57 li = ['alex', 'wusir', 'egon', '女神', 'why']
58 # li[0:2] = 12    # 报错 12不可迭代
59 # print(li)
60
61 # 查 查列表中的每一个元素
62 for i in li:
63     print(i)
64
65 # 查 切片查
66 print(li[0:2])  # ['alex', 'wusir']
67
68 # 公共方法, len 计算可迭代对象中的含几个元素
69 print(len(li))  # 5
70
71 # 公共方法，count 计算元素的出现次数
72 print(li.count('alex'))
73
74 # 找列表中的元素的索引值， index 找不到会报错
75 print(li.index('why'))  # 4
76
77 li = [1, 5, 4, 7, 6, 2, 3, 9, 0]
78 # 列表元素正向排序 sort, 从小到大排序
79 li.sort()
80 print(li)   # [0, 1, 2, 3, 4, 5, 6, 7, 9]
81
82 # 列表元素反向排序 sort(reverse=True)
83 li.sort(reverse=True)
84 print(li)   # [9, 7, 6, 5, 4, 3, 2, 1, 0]
85
86 # 列表元素顺序反转
87 li.reverse()
88 print(li)   # [0, 1, 2, 3, 4, 5, 6, 7, 9]

　　5.2 列表的嵌套

 1 # 列表的嵌套
 2
 3 li = ['why', 'alex', '武藤兰', 'python', ['wusir', 'egon', 89], 23]
 4
 5 print(li[2][1])     # 藤
 6
 7 li[0]= li[0].capitalize()  # 第一个元素变为首字符大写
 8 print(li)   # ['Why', 'alex', '武藤兰', 'python', ['wusir', 'egon', 89], 23]
 9
10 li[4][0] = li[4][0].upper()  # 将wusir变为大写
11
12 print(li)   # ['Why', 'alex', '武藤兰', 'python', ['WUSIR', 'egon', 89], 23]

　　6.tuple元组

　　也叫只读列表，只能读，不能被修改。可以查询但不能被更改。同时可以切片。

 1 # 元祖 只读列表，可循环查询，可切片
 2 # 儿子不能被改，孙子可可能可以改
 3 tu = (1, 2, 3, 'alex', [2, 3, 4, 'why'], 'egon')   # 里面的整个元素不能被改,但是元素如果不是元组是列表，列表中的内容可以改
 4
 5 print(tu[3])    # alex
 6
 7 print(tu[0:4])  # (1, 2, 3, 'alex')
 8
 9 for i in tu:
10     print(i)
11
12 tu[4][3] = tu[4][3].upper() # why 改为大写
13
14 print(tu)   # (1, 2, 3, 'alex', [2, 3, 4, 'WHY'], 'egon')
15
16 # tu[4] = tu[4].append('SB')  # 报错，
17 tu[4].append('SB')
18 print(tu)   # (1, 2, 3, 'alex', [2, 3, 4, 'WHY', 'SB'], 'egon')

　　7.dict字典

　　可存储大量数据，关系型。关系型数据要存储在字典中。

  1 # dict
  2 '''
  3 数据类型划分:可变数据类型，不可变数据类型
  4 不可变数据类型：tuple，bool，int str，又叫可哈希
  5 可变数据类型：list，dict，set(集合)， 又叫不可哈希
  6
  7 dict key： 必须是不可变数据类型，也就是可哈希，tuple，bool，int，str
  8      value：任意数据类型
  9
 10 dict 优点：二分查找去查询
 11           存储大量关系型数据
 12      特点：无序的(python3.5包含以前的都是无序的)
 13
 14 '''
 15
 16 # dic = {
 17 #     'name' : ['why', 'python', '关羽'],
 18 #     'py9' : [{'num' : 108, 'avg_age' : 18}],
 19 #     True : 1,
 20 #     (1, 2, 3) : 'wuyiyi',
 21 #     2 : '赵云'
 22 # }
 23 #
 24 # print(dic)
 25
 26 dic = {'age' : 18, 'name' : 'why', 'sex' : 'male'}
 27
 28 # 增
 29 dic['high'] = 170  # 没有键就是增加，有就是更改
 30 print(dic)  #   {'high': 170, 'age': 18, 'name': 'why', 'sex': 'male'}
 31
 32 dic['age'] = 16     # 如果有键值会覆盖
 33 print(dic)      # {'high': 170, 'age': 16, 'name': 'why', 'sex': 'male'}
 34
 35 # 增 setdefault
 36 dic.setdefault('weight', 120)
 37 print(dic)  # {'weight': 120, 'high': 170, 'sex': 'male', 'name': 'why', 'age': 16}
 38
 39 dic.setdefault('age', 20)   # 有键值对，不做任何改变，没有那个键值对则添加
 40 print(dic)  # {'weight': 120, 'high': 170, 'sex': 'male', 'name': 'why', 'age': 16}
 41
 42
 43 # 删 按照键去删
 44 print(dic.pop('age'))   # 有返回值  16
 45 print(dic)      # {'sex': 'male', 'name': 'why', 'weight': 120, 'high': 170}
 46
 47 print(dic.pop('哈哈', None))  # 返回None 没有哈哈这个键时，则返回None，返回值可设置，有哈哈这个键则删除哈哈这个键值对
 48 print(dic)
 49
 50 print(dic.popitem())   # 随机删除 返回值是元组形式的键和值
 51 print(dic)
 52
 53 # 清空字典
 54 dic.clear()
 55 print(dic)
 56 dic = {'age' : 18, 'name' : 'why', 'sex' : 'male'}
 57
 58 # del也可删除键值对
 59 del dic['name']
 60 print(dic)
 61
 62 # 删除字典
 63 # del dic
 64
 65
 66 # 改
 67 dic = {'age' : 18, 'name' : 'why', 'sex' : 'male'}
 68
 69 dic['age'] = 25
 70 print(dic)
 71
 72 # 改 update
 73 dic2 = {'name' : 'fqq', 'weight' : 120}
 74 dic.update(dic2)    # 将dic2内容更新到dic中，如果dic中没有则新增，如果dic中有则覆盖
 75 print(dic)
 76 print(dic2)
 77
 78
 79 # 查
 80 dic = {'age' : 18, 'name' : 'why', 'sex' : 'male'}
 81 print(dic.keys(), type(dic.keys()))     # dic.keys()返回的当成list，返回的list中全是键   dict_keys(['sex', 'age', 'name']) <class 'dict_keys'>
 82 print(dic.values())     # 返回的也相当于list，list里面放的全是值       dict_values(['male', 18, 'why'])
 83 print(dic.items())      # 返回的也相当于list，list里都是元祖，元组里是键值对   dict_items([('sex', 'male'), ('age', 18), ('name', 'why')])
 84
 85 for i in dic:
 86     print(i)    # 打印的全是键
 87
 88 for i in dic.keys():
 89     print(i)    # 打印的全是键
 90
 91 for i in dic.values():
 92     print(i)    # 打印的全是值
 93
 94 a = 1
 95 b = 2
 96 a, b = b, a
 97 print(a, b)     # 2 1
 98
 99 a, b = [1, 2]
100 print(a, b)     # 1 2
101
102 a, b = [1, 2], [2, 3]
103 print(a, b)     # [1, 2] [2, 3]
104
105 a, b = (1, 2)
106 print(a, b)     # 1 2
107
108 # ('sex', 'male')
109 # ('name', 'why')
110 # ('age', 18)
111 for i in dic.items():   # items返回的是list，list中有元组，元组内容为键值对
112     print(i)
113
114
115 # sex male
116 # age 18
117 # name why
118 for k, v in dic.items():
119     print(k, v)
120
121
122 # 查
123 dic = {'age' : 18, 'name' : 'why', 'sex' : 'male'}
124
125 print(dic['name'])  # why
126
127 # print(dic['sdf'])   # 报错，字典中没有这个键值对是会报错
128
129 # 查 get
130 print(dic.get('name'))  # why
131 print(dic.get('sdf'))   # None  没有不会报错，默认会返回None
132
133 print(dic.get('sdf', '没有这个键'))  # 没有这个键, 没有不会报错，会返回设置的值

　　7.1 dict的嵌套

 1 # dict嵌套
 2
 3 dic = {
 4     'name' : ['alex', 'wusir', 'python'],
 5     'py9'  :{
 6         'time' : '1213',
 7         'learn_money' : 19800,
 8         'address' : 'CBD',
 9     },
10     'age' : 25
11 }
12
13 # 将age的值改为56
14
15 dic['age'] = 56
16
17 # 将name对应的列表中添加一个新的名字
18 dic['name'].append('赵云')
19
20 # 将wusir变为全大写
21 dic['name'][1] = dic['name'][1].upper()
22
23 # 将py9对应的字典添加一个键值对 female : 8
24 # dic['py9']['female'] = 6    # 或 dic['py9'].setdefault('female', 6)
25
26 print(dic)

　　8.for 循环

　　for x in 可迭代的对象(由很多个元素的):

　　　　pass

1 s = 'fhdsklfds'
2 for i in s:
3     print(i)

 1 # 循环打印这个list，但是遇到list中的list也要循环打印出
 2 li = [1, 2, 3, 5, 'alex', [2, 3, 4, 5, 'why'], 'python']
 3
 4
 5 for i in li:
 6     if type(i) == list:
 7         for j in i:
 8             print(j)
 9     else:
10         print(i)

　　8.1 补充range

 1 # range 一般都与for配合使用.range 顾头不顾尾。可以看成一个list，但是里面都是数字
 2 for i in range(0, 100):
 3     pass
 4
 5 for i in range(10):   # 从0开始，可以不写头
 6     pass
 7
 8 for i in range(0, 10, 2):  # 可以加步长
 9     pass
10
11 for i in range(10, 0, -1):  # 可以倒着
12     #print(i)
13     pass
14
15 for i in range(0, 10, -1):
16     print(i)    # 什么都没有

　　9. 补充join

 1 # join 可迭代对象都可以用其操作
 2
 3 s = 'alex'
 4
 5 s1 = '_'.join(s)    # a_l_e_x 将s这个可迭代对象，将每个迭代出来的元素用'_'连接,最终返回的是一个str
 6
 7 print(s1)
 8
 9 li = ['why', 'alex', '武藤兰', 'python']
10 s = ''.join(li)
11 print(s)    # whyalex武藤兰python
12
13 # 想让字符串转换为list可用str的split方法，想让list转换为str可用join方法

　　10.补充例子

1 # 获取用户的输入，判断含整体数字的个数
2 info = input('>>>')
3 for i in info:  # info因为是不可变的，for认为info不会变，所以遍历的元素这里已经固定，所以下面的赋值并不会这里，
4     if i.isalpha():  # 判断是否是字符
5         info = info.replace(i, ' ')  # 将所有字符替换未空格符
6
7 l = info.split()  # 默认用any空白字符进行分隔， spilit得到的是list，list中元素全是数字
8
9 print(len(l))

　　11.基础类型汇总补充

　　想看每个数据类型的所有操作方法，如果使用pycharm，则ctrl + 鼠标左键，可跳过去有所有方法。

 1 # list 在循环list当中，将list中的元素删除
 2 lis = [11, 22, 33, 44, 55]
 3
 4 # 报错,因为list是可变数据类型，不可哈希，删除list中的一个元素后，list中就少一个，而i是0到5，所以后面i索引的位置已经没了t元素
 5 # range(len(lis))只认一次，只确定一次，所以range(len(lis))得到5后一直不变
 6 # for i in range(len(lis)):
 7 #     print(i)
 8 #     print(lis)
 9 #     del lis[i]
10
11
12
13 # 循环的方式，将lis中的奇数索引位置的数据删除掉
14 # 不可以的方法
15 lis = [11, 22, 33, 44, 55, 66, 99]
16 for i in lis:
17     print(lis.index(i))
18     print(lis)
19     if lis.index(i) % 2 == 1:
20         lis.remove(i)
21
22 print(lis)
23
24
25 # 删除字典中，含有k元素的键值对
26 dic = {'k1' :'v1', 'k2' : 'v2', 'a3' : 'v3'}
27
28 # 此种方法会报错
29 # for i in dic:
30 #     if 'k' in i:
31 #         print("===")
32 #         del dic[i]
33 # 此种方法可以
34 # dic1 = {}
35 # for i in dic:
36 #     if 'k' not in i:
37 #         dic1.setdefault(i, dic[i])
38 # dic = dic1
39 # print(dic)
40
41 # 此种方法也可以，循环字典删除字典元素不可以，就使用循环字典，将要删除的键放入到list中，循环list进行删除dic
42 l = []
43 for i in dic:
44     if 'k' in i:
45         l.append(i)     # l 中全是含有k的键
46 for i in l:
47     del dic[i]
48 print(dic)
49
50 # 不要在循环list和循环dic中删除list和dic元素
51
52 # 元祖
53 tu1 = (1)   # 元组中只有一个元素，并且不没有逗号，那此元素是什么类型，就是什么什么类型，并不是元组类型
54 tu2 = (1, )     # 元组括号内有一个元素，并有逗号，就是元组