Python基础 | 数据类型

基础数据类型，有7种类型，存在即合理。

1.int 整数

　　主要是做运算的。比如加减乘除，幂，取余 + - * / ** %...
2.bool 布尔值

　　判断真假以及作为条件变量
3.str 字符串

　　存储少量的数据。比如\'password\'... 操作简单，便于传输。
4.list 列表

　　[1,2,\'alex\',{name:\'zhang\'}] 存放大量的数据，大量的数据放到列表中便于操作
5.tuple 元组

　　也叫只读列表。(1,2,\'alex\',{name:\'zhang\'}) 一些重要的数据或者不想被更改的数据，使用元组
6.dict 字典

　　{‘name_list’:\'[zhang,lisi]\'}, 存储关系型的数据,查询速度非常快，二分查找。
7.set 集合

　　交集，并集，差集...

数据类型的分类:

可变数据类型(不可哈希)：list,dict,set

不可变数据类型(可哈希)：int,bool,str,tuple

容器类型：

容器类(承载各种数据类型)：list,tuple,dic

一、int整形

主要用于计算，计数，+ - * / % ** ....

32位系统，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647

64位系统，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

float：浮点数，复数

bit_length()：转化成二进制的最小位数

二、bool 布尔值

数据类型转换：

int <---> str： int(str)、str(int)

int <---> bool：非零即True，零为False bool(1).

bool <---> str：

　　①str ---> bool：非空即True，空字符串对应 False。 print（bool（\'Alex\'））结果为 True

　　②bool ---> str：只能打印True和False，没有什么实际意义

1 例子：
2 n = str(1)    　　　　　　 # 1
3 n = bool(1)    　　　　    #True
4 n = bool(\'\')    　　　　　 # False. 空字符串是False，其他都是True

三、str 字符串

在python中，凡是用引号引起来的数据都是字符串。单引号，双引号，三引号引起来没有任何区别。

1 s1 = \'小明\'
2 s2 = "小明"
3 s3 = """小明"""
4 print(s1,s2,s3) 　　　　    #都是小明。 小明，小明，小明

1. 单双引号配合使用

1 msg = "My name is Ming , I\'m 73 years old!" 　　    # 里面是单引号，所以外面用双引号比较好

2. 三引号用于换行的字符串

 1 msg = \'\'\' 
 2 今天我想写首小诗，
 3 歌颂我的同桌，
 4 你看他那乌黑的短发，
 5 \'\'\'
 6 print(msg)

结果显示：
今天我想写首小诗，
歌颂我的同桌，
你看他那乌黑的短发，

3.字符串相加和相乘

相加 ：拼接。

s1 = \'a\'
s2 = \'b\'
print(s1 + s2)      #ab

相乘

s3 = \'a\'
print(s3*8)         # aaaaaaaa

4.字符串重要操作　　　　*****

4.1 字符串的取值（索引、切片、步长）

①按照索引取值

1 s = \'abcdefgh\'
2 s1 = s[0]          # 取第一个值
3 s2 = s[-1]         # 取最后一个值

②按切片取值，顾头不顾尾。切片，也就是取连续的多个值

 1 s = \'abcdefgh\'
 2 s1 = s[0:6]     # 按切片取值，顾头不顾尾
 3 s2 = s[:6]      # 从0开始取值，0可以省略
 4 s3 = s[6:]      # 从某一索引取到最后的值，冒号后面不跟值
 5 s4 = s[-5:]     # 取最后5个字符串
 6 s5 = s[:]       # 取所有
 7 
 8 print(s1)
 9 print(s2)
10 print(s3)
11 print(s4)
12 print(s5)

结果显示：
abcdef
abcdef
gh
defgh
abcdefgh

对字符串操作，都会产生新的变量，除了赋值以外。

③按照切片+步长取值　　[起始索引：截止索引：步长]

步长：

（1）默认步长为1

（2）隔一个取1个，步长为2

（3）反向取值，也就是从后向前取，步长为-1

 1 s = \'abcdefgh\'
 2 s1 = s[:5:2]    # 从第一个字符到第五个字符，每隔一个字符取一个值。
 3 s2 = s[1::2]    # 从第二个字符到最后一个字符，每隔一个字符取一个值，最后一个字符的位置不能写值。
 4 s3 = s[::2]     # 隔1个，取一个
 5 
 6 print(s1)
 7 print(s2)
 8 print(s3)

结果输出：
ace
bdfh
aceg

倒叙取值，加一个反向步长*****

 1 s = \'abcdefgh\'
 2 s1 = s[::-1]        # 反向全取
 3 s2 = s[-1:-6:-2]    # 划士期
 4 s3 = s[:-5:-1]      # 反向取5个
 5 s4 = s[-1:-5:-1]    
 6 
 7 print(s1)
 8 print(s2)
 9 print(s3)
10 print(s4)

结果输出：
hgfedcba
hfd
hgfe
hgfe

4.2 字符串的常用方法

①　capitalize()：首字母大写，其他字母小写 ***

②　upper()、lower()：字母全部大写/小写 *****

1 name = \'Summer\'
2 print(name.capitalize())        #Summer
3 print(name.upper())             # SUMMER
4 print(name.lower())             # summer

可用于验证码输入，如果不使用字符串内置方法，这需要写16个if，代码质量非常low

1 code = \'Summer\'.upper()
2 your_code = input(\'请输入验证码：\').upper()
3 if your_code == code:
4     print(\'验证码验证成功\')

③　swapcase()：大小写反转 **

④　title()：非字母隔开的首字母大写**

1 s1 = \'sumer aaa#bbbb*cc6ddd\'
2 print(s1.title())  　　　　　　　　　　　　# Sumer Aaa#Bbbb*Cc6Ddd

⑤　startswith()、endswith()：判断是否以...开头或结尾，返回bool值

endswith()的用法与startswith()相同 *****

s = \'summer wusir*nanhai21shui\'
s1 = s.startswith(\'a\')  
s2 = s.endswith(\'i\')  

# 切片,取索引访问1~4,再判断是否以i开头
s3 = s.startswith(\'i\', 1, 4)  

# 切片,取索引范围5~结束,结束位置参数没给，默认一直取到尾
s4 = s.startswith(\'w\', 5)  

print(s1,s2,s3,s4)              # False True False False

# 查看是否以 t 或 b 或 h 开头
s.startswith((\'t\',\'b\',\'h\'))

⑥　通过元素找索引（ find( )，index( ) ）：找到第一个元素就返回，返回int *****

1 name = "summer"
2 print(name.find(\'u\'))  　　　　　　　　# 返回u在字符串中的位置，返回1
3 print(name.find(\'mm\'))  　　　　　　　　# 返回lD在字符串中的位置，返回2
4 print(name.find(\'w\'))  　　　　　　　　# 返回w在字符串中的位置，字符串中没有w，返回-1
5 print(name.find(\'e\', 1, -1))  　　　　# 从位置1到最后查找2的位置，返回4

index()的用法和find()相同，只是index()没有找到会报错，find()没有找到返回-1

⑦　center()：字符串居中，前后填充自定义字符 **

总宽度为30,并且字符串居中,不足30，默认用空格填充

1 s = \'laoshi\'
2 s1 = s.center(30)
3 print(s1)           #            laoshi

#使用*填充

1 s = \'laoshi\'
2 s2 = s.center(30,\'*\')
3 print(s2)               #************laoshi************

如果宽度小于字符串，按照原来的字符串显示

1 s = \'laoshi\'
2 s2 = s.center(3,\'*\')
3 print(s2)               #laoshi

⑧　strip()：去除字符串开头和结尾的空格.换行符.制表符,不能删除中间的

在input程序中，会经常使用，如果用户输入的，不小心包含了空格，会导致验证失败,下面加入strip(),即使输入有空格，也可以验证通过

1 name = input(\'请输入用户名：\').strip()
2 
3 if name == \'summer\':
4     print(\'ok\')

类似功能的2个的方法

　　lstrip() 去除左边的空格、换行符、tab键

　　rstrip() 去除右边的空格、换行符、tab键

strip()还可以去除指定的字符串

strip会优先匹配最长的，不一定是这个组合的，主要是包含这几个字母的都可以

1 s = \'laoshijintianzai\'
2 s1 = s.strip(\'l\') #去除字符串l
3 print(s1)         #aoshijintianzai
4 
5 strip()会同时向左右2边，挨个挨个字符寻找字符串l 如果发现了l就去除，如果没有发现终止寻找

⑨　split()：将字符串分割成列表，默认按照空格分割，实现字符串--->列表的转化 *****

不写时，默认表示用空格，\n，\t 分隔字符串：

1 s1 = \'spring summer autumn winter\'
2 l1 = s1.split()
3 
4 print(l1)  # [\'spring\', \'summer\', \'autumn\', \'winter\']

此处的空格是指\s+，所以1个空格，多个空格、tab键都会被当成分隔符

>>> str = "a     b"
>>> str.split()
[\'a\', \'b\']


>>> str = "a\tb"
>>> str.split()
[\'a\', \'b\']

指定分割符

1 s1 = \'spring,summer,autumn,winter\'
2 l1 = s1.split(\',\')
3 
4 print(l1)  # [\'spring\', \'summer\', \'autumn\', \'winter\']

指定字符串a

1 s1 = \'springasummeraautumnawinter\'
2 l1 = s1.split(\'a\')
3 
4 print(l1)  # [\'spring\', \'summer\', \'\', \'utumn\', \'winter\']

注意：如果关键字左边没有字符串，那么结果为[]，也就是空字符串。结果不包含关键字，被剔除了

⑩　join()：自定制连接符，将可迭代对象中的元素连接起来，是列表转化为字符串的方式

1 s=\'summer\'
2 s2=\'*\'.join(s)               # 和其他方法不一样，请注意
3 print(s2)                       #s*u*m*m*e*r

⑪　repalce()：替换，可设置替换次数 *****

s = \'我的老家在东北，东北有很多人\'

默认是全文替换

1 s = \'我的英文名叫夏天，因为夏天总是那么阳光明媚\'
2 s1 = s.replace(\'夏天\', \'春天\')
3 print(s1)

替换一次

1 s = \'我的英文名叫夏天，因为夏天总是那么阳光明媚\'
2 s1 = s.replace(\'夏天\', \'春天\',1)
3 print(s1)                                           # 我的英文名叫春天，因为夏天总是那么阳光明媚

替换，是从左至右的.如果想要替换中间某部分，需要用到正则表达式

⑫　格式化输出 format()

第一种用法：{}表示一个占位符

1 s = \'我叫{},今年{},爱好{}\'.format(\'summer\', 18, \'滑雪\')
2 print(s)                                    # 我叫summer,今年18,爱好滑雪

第二种用法：

比如某个变量出现了几十次，那么可以直接用个{索引}表示，修改format后面的参数，就可以生效了

1 s = \'我叫{0},今年{1},爱好{2},即便是81岁我依然叫爱{2}\'.format(\'summer\', 18, \'滑雪\')
2 print(s)  　　　　　　　　　　　　　　　　　　# 我叫summer,今年18,爱好滑雪,即便是81岁我依然叫爱滑雪

{2} 表示索引值，如果使用这种方式，索引值必须指定，否则报错

第三种用法：键值对

1 s = \'我叫{name},今年{age},爱好{hobby}\'.format(age=18, name=\'summer\', hobby=\'滑雪\')
2 print(s)  　　　　　　　　　　　　　　　　　　# 我叫summer,今年18,爱好滑雪

1 s1 = \'我叫{},今年{}，性别{}\'.format(\'summer\', \'18\', \'女\')
2 s2 = \'我叫{0},今年{1}，性别{2}，我依然叫{0}\'.format(\'summeri\', \'18\', \'女\')
3 s3 = \'我叫{name},今年{age}，性别{sex}\'.format(name=\'summer\', sex=\'女\', age=\'18\')

⑬　is 系列，返回bool值

1 name=\'summer123\'
2 print(name.isalnum()) 　　　　　　　　#判断是否是数字或字母组成
3 print(name.isdigit()) 　　　　　　　　#判断是否是数字组成
4 print(name.isalpha()) 　　　　　　　　#判断是否是字母组成

isdigit()比较常用，比如判断用户输入的，是否是数字。

或者将字符串转换为数字类型时，要判断字符串是否由纯数字组成，否则报错。

1 name = \'123a\'
2 if name.isdigit():
3     name = int(name)
4 else:
5     print(\'您输入的含有非数字元素\')

执行输出：您输入的含有非数字元素

⑭　公共方法：count()

1 name = \'summer\'
2 print(name.count(\'m\'))  　　　　　　# 统计a出现的次数 2
3 print(len(name))  　　　　　　　　　　# 查看数据的长度 6

四、列表

列表是python中的基础数据类型之一，它是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型。比如：

li = [‘a’, 123, Ture, (1,2,3,’b’), [1,2,3,’小明’,], {‘name’:’summer’}]

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据。列表是有序的

索引，切片，步长

列表的索引与字符串相同，都是索引、切片、步长

 1 li = [\'xiao\',123,True,(1,2,3,\'a\'),[1,2,3,\'小明\',],{\'name\':\'xiao\'}]
 2 print(li[0])
 3 print(li[2])
 4 print(li[1:4])
 5 print(li[:5:2])
 6 print(li[-1:-3:-1]) # 倒着取，后2个

输出结果：
xiao
True
[123, True, (1, 2, 3, \'a\')]
[\'xiao\', True, [1, 2, 3, \'小明\']]
[{\'name\': \'xiao\'}, [1, 2, 3, \'小明\']]

列表的增、删、改、查

增

①　append()：在列表的最后追加，没有返回值

②　insert()：根据位置增加

③　extend()：在列表的最后追加，按照最小单元形式

append() 追加，在最后一个位置添加元素

1 li = [1,\'a\',\'b\',2,3,\'a\',\'lao\']
2 li.append(\'xiao\')
3 print(li) # [1, \'a\', \'b\', 2, 3, \'a\', \'lao\', \'xiao\']

1 l1 =[\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\' ,]
2 l1.append([1 ,2 ,3])
3 
4 # print(l1.append([1,2,3])) 　　　　　　　　　　#没有返回值，因为l1.append([1,2,3])是一个过程
5 
6 print(l1) 　　　　　　　　　　　　　　　　　　　　# [\'spring\', \'summer\', \'autumn\', \'winter\', [1, 2, 3]]

insert() 按照索引添加

将元素插入到指定的索引值位置, 后面的元素索引值会自动加1

1 li =[\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\' ,]
2 li.insert(2,\'zhang\') # 先索引，后内容
3 print(li) # [\'spring\', \'summer\', \'zhang\', \'autumn\', \'winter\']

extend() 迭代着添加

在最后的位置，迭代每一个元素，依次添加。

1 li =[\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\' ,]
2 li.extend(\'ABC\')
3 print(li) # [\'spring\', \'summer\', \'autumn\', \'winter\', \'A\', \'B\', \'C\']

使用输入框方式添加元素

 1 name_list =[\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\' ,]
 2 
 3 while True:
 4     name = input(\'请输入新员工姓名：Q/q \').strip()
 5     if name.upper() == \'Q\':
 6         break
 7     else:
 8         name_list.append(name)
 9 
10         print(\'已成功添加新员工%s\' % name)
11 
12 print(name_list)

删

1) pop()：按照索引的位置删除，有返回值，返回值是被删除的元素

2) remove()：按照元素删除

3) clear()：清空

4) del[ ]：按照索引的位置删除（ 中括号，和其他不一样）

按照切片和步长删除

全部清空

pop() 按照索引删除

#默认删除最后一个

1 li =[\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\' ,]
2 li.pop()
3 print(li)           #[\'spring\', \'summer\', \'autumn\']

删除索引值为1的元素

1 li =[\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\' ,]
2 li.pop(1)
3 print(li)           #[\'spring\', \'autumn\', \'winter\']

pop() 是增删改查所有方法里面，唯一有返回值的方法。返回删除的元素。pop()只能删除一个元素

remove() 按照元素删除，只能删除一个

1 li =[\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\' ,]
2 li.remove(\'summer\')
3 print(li)           #[\'spring\', \'autumn\', \'winter\']

clear() 清空列表的所有元素

1 li =[\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\' ,]
2 li.clear()
3 print(li)           #[]

del 删除列表

1 li =[\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\' ,]
2 del li

# 按索引删除

1 li =[\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\' ,]
2 del li[0]
3 print(li)           # [\'summer\', \'autumn\', \'winter\']

# 按切片删除

1 li =[\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\' ,]
2 del li[:3]
3 print(li)           # [\'winter\']

# 按照切片+步长删除

1 li =[\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\' ,]
2 del li[::2]
3 print(li)           # [\'summer\', \'winter\']

# 跳着删除

1 li =[\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\' ,]
2 del li[:3:2]
3 print(li)           # [\'summer\', \'winter\']

改

1) 按索引更改

2) 按切片更改：可在切片位置放任意多个参数

3) 按切片加步长更改：只能按照切片宽度放置参数个数

使用赋值修改

# 按索引更改，一次只能更改一处

1 li =[\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\' ,]
2 li[0] = \'abc\'
3 print(li)           # [\'abc\', \'summer\', \'autumn\', \'winter\']

# 按切片更改

1 li =[\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\' ,]
2 li[:4]=[11,22,33,44,55,66]
3 print(li)           # [11, 22, 33, 44, 55, 66]

#按切片加步长更改

1 li =[\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\' ,]
2 li[:4:2]=[11,22]
3 print(li)           # [11, \'summer\', 22, \'winter\']

切片修改的执行过程是，先删除切片部分，再迭代添加的对象，依次添加元素。

查

1) 按照索引查；

2) 用for循环

for 循环

1 li =[\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\' ,]
2 for i in li:
3     print(i)

其他操作方法：

①列表可以相加

1 l1 =[\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\' ,]
2 l2=[1,2,3]
3 l3=l1+l2
4 
5 print(l3)           # [\'spring\', \'summer\', \'autumn\', \'winter\', 1, 2, 3]

② 在循环一个列表时，删除列表中的某一元素时，该元素后面的元素都会向前进一位，后面元素的索引会改变。所以在循环一个列表时，最好不要对列表进行改变大小的操作（增和删）

例题：将列表中索引为奇数的元素删除

方法1：将列表中索引为偶数的元素加入到一个新的列表中

方法2：从列表后面开始删除

方法3：切片

l1=[11,22,33,44,55,66,77,88]

方法一

使用新列表覆盖

 1 l2 = []
 2 
 3 for i in range(len(l1)):
 4     if i % 2 == 0:
 5         l2.append(l1[i])
 6 
 7 li = l2
 8 print(li)

方法二

1 for i in range(len(l1),-1,-1):
2     if i % 2 == 1:
3         l1.pop(i)
4 
5 print(l1)

倒序删除

1 for i in range(len(l1)-1,-1,-1):
2     if i % 2 == 1:
3         del l1[i]
4 
5 print(l1)

方法三

1 l3 = l1[::2]
2 print(l3)

1 del l1[1::2]
2 print(li)

sort()

# 从小到大，正向排序

1 li = [1,2,7,8,5,6,3,4]
2 li.sort()
3 
4 print(li) 　　　　　　　　　　# [1, 2, 3, 4, 5, 6, 7, 8]

# 从大到小，反向排序

1 li = [1,2,7,8,5,6,3,4]
2 li.sort(reverse=True)
3 
4 print(li)     　　　　　　# [8, 7, 6, 5, 4, 3, 2, 1]

reverse() 翻转

翻转，就是将右边的元素和左边的元素进行对换。

1 li = [1,2,7,8,5,6,3,4]
2 li.reverse()
3 print(li)  　　　　　　　　# [4, 3, 6, 5, 8, 7, 2, 1]

任何排序都不如sort和reverse 快, 如果没有明确要求指定排序方法，优先使用sort和reverse

len() 查看数据长度

1 li = [1,2,7,8,5,6,3,4]
2 print(len(li)) 　　　　　　　　# 8

count() 统计元素出现次数

1 li = [1,2,7,8,5,6,3,4]
2 print(li.count(7))     　　　　# 1

index() 通过元素找索引

1 li = [1,\'a\',\'b\',\'a\',2,3,\'a\']
2 print(li.index(\'a\'))     　　# 1

列表的嵌套（注意:只要涉及到字符串变更的，都需要重新赋值）

li = [1,2,\'summer\',[\'100\',\'spring\',99],22]
1.将summer 变成首字母大写的Summer
li[2] = li[2].capitalize()

2.将spring变成全部大写的SPRING放到原处
li[3][1] = li[3][1].upper()

3.将99加1变成100，返回原处
#数值加1
li[3][2] += 1
print(li)

思考题：将列表中的每一个元素打印出来，如果遇到列表，需要打印列表中的每一个元素 *****

答案：

li = [1, 2, [\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\'], \'a\', \'b\']
for i in li:
    if type(i) == list:
        for j in i:
            print(j)
    else:
        print(i)

输出结果：
1
2
spring
summer
autumn
winter
a
b

如果列表包含字典以及元组呢？ li = [1,2,[\'alex\',\'wusir\'],\'a\',\'b\',{\'name\':\'xiao\',\'age\':21},(\'d\',\'n\',\'f\')]

第1种写法： *****

 1 li = [1, 2, [\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\'], \'a\', \'b\']
 2 for i in li:
 3     #判断元素类型是否是整形和布尔值，除了这2种类型，其他类型都是可迭代对象
 4     if type(i) not in [int,bool]:
 5         # 判断元素的长度等于1，排除有多个元素的数据，比如列表，字典...
 6         if len(i) == 1:
 7             print(i)
 8         else:
 9             #循环可迭代对象
10             for j in i:
11                 print(j)
12     else:
13         print(i)

第2种写法： *****

 1 #加载模块
 2 from collections import Iterable
 3 
 4 li = [1, 2, [\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\'], \'a\', \'b\']
 5 for i in li:
 6     #判断是否是可迭代对象
 7     if isinstance(i,Iterable):
 8         for j in i:
 9             print(j)
10     else:
11         print(i)

执行程序，效果同上

五、元组tuple

元组被称为只读列表，即数据可以被查询，但不能被修改.

1、查询方式：与列表相同

2、可使用公用方法index、count、len

3、应用场景：一些非常重要的数据不允许任何人修改就放在元组种。

4、元组的儿子不能修改，但是孙子可以修改

如果一个元组只由一个数据组成，且没有逗号，那么该“元组”的数据类型就是该数据的数据类型

 1 tu1 = (1)
 2 tu2 = ("hello")
 3 tu3 = ([1,2,3])
 4 tu4 = ({1:1,2:2})   
 5 
 6 print(type(tu1))    #<class \'int\'>
 7 print(type(tu2))    #<class \'str\'>
 8 print(type(tu3))    #<class \'list\'>
 9 print(type(tu4))    #<class \'dict\'>
10 
11 tu5 = (1,)           #有逗号，还是元组类型
12 print(type(tu5))    #<class \'tuple\'>

字符串的切片操作同样适用于元组。

1 tu = (\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\')
2 print(tu[:2])  　　　　　　　　　　　　# (\'spring\', \'summer\')
3 print(tu[2])  　　　　　　　　　　　　 # 指定索引取值 autumn

遍历元祖

1 tu = (\'spring\' ,\'summer\' ,\'autumn\' ,\'winter\')
2 for i in tu:
3     print(i)

有一种情况，元组的值会改变，俗称：儿子不能改，孙子可能改

1 tul1 = (\'spring\' ,\'summer\' ,[\'hot\', 99, \'cool\'],\'autumn\' ,\'winter\')
2 
3 # tul1[0] = \'namsahn\'  　　　　　　　　　　# 元组里儿子不允许修改,会报错
4 tul1[2][0] = 123  　　　　　　　　　　　　  # 元组里的孙子辈可以增删改
5 tul1[2].append(\'a\')
6 
7 print(tul1)             # (\'spring\', \'summer\', [123, 99, \'cool\', \'a\'], \'autumn\', \'winter\')

一般元组，是放只读的数据。所以不会随意更改。元组是只读列表，只允许查询，不允许增、删、改

元组转换为列表

1 tu = (1,2,3)
2 li = list(tu)
3 print(li) 　　　　　　　　# [1, 2, 3]

列表转换为元组

1 tu = [1,2,3]
2 li = tuple(tu)
3 print(li) 　　　　　　# (1, 2, 3)

字符串直接转换为元组是没有方法的。除非把字符串转换为列表，再转换为元组

六、字典

字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。

字典使用二分查找.二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。比如字典有1～100的数据，现在想要查找75。先劈一半，找到中间值50。判断50和75的大小，发现小于，再劈一半。找到中间值75，直接返回结果。

数据类型的分类:

可变数据类型(不可哈希)：list,dict,set

不可变数据类型(可哈希)：int,bool,str,tuple

容器类型：

容器类(承载各种数据类型)：list,tuple,dic

字典的键：必须是不可变数据类型；字典的值：任意数据类型；字典的键是唯一的。

例如：

dic = {\'name_list\': [\'王双\', \'alex\', \'孙飞\', \'taibai\'],
       1: {\'name\': \'taibai\', \'age\': 18, \'sex\': \'男\'},
       (1, 2): [100, {\'ip\': \'192.168.1.1\', \'port\': 3306}]
       }

字典的顺序:严格意义上来讲，是无序的。 3.5之前，字典是无序的。3.6开始，字典创建的时候，按照一定的顺序插入的值，看起来是有序的

1、创建字典的三种方式

① dic = {}

② dic = dict( { } )

③ dic.fromkeys(可迭代对象，value)，value会被赋值可迭代对象里的每一个值

1 dic = dict.fromkeys(\'abc\',\'alex\')
2 print(dic)　　　　　　　　# {\'c\': \'alex\', \'b\': \'alex\', \'a\': \'alex\'}
3 
4 使用列表创建一个新字典
5 dic = dict.fromkeys([1,2,3],[])
6 print(dic)　　　　　　　　# {1: [], 2: [], 3: []}

字典的第一个坑

给列表1添加一个元素

1 dic = dict.fromkeys([1,2,3],[])
2 dic[1].append(\'北京\')
3 print(dic)                  # {1: [\'北京\'], 2: [\'北京\'], 3: [\'北京\']}

坑就来了，这3个列表，在内存中对应的是同一个列表

字典的第二个坑：在循环一个字典时，对字典的键值对进行删除会报错。

将字典中含有K元素的键，对应的键值对删除

dic = {\'k1\':\'value1\',\'k2\':\'value2\',\'name\':\'summer\'}

正常思路的写法：

 1 dic = {\'k1\':\'value1\',\'k2\':\'value2\',\'name\':\'summer\'}
 2 
 3 for i in dic.keys():
 4     if \'k\' in i:
 5         dic.pop(i)
 6 
 7 print(dic)

　　执行报错：RuntimeError: dictionary changed size during iteration

意思就是，在循环字典过程中，不允许改变字典

换一种思路，在字典中追加：

1 dic = {\'k1\':\'value1\',\'k2\':\'value2\',\'name\':\'summer\'}
2 count = 0
3 
4 for i in dic:
5     dic[i+str(count)] = dic[i]
6     count +=1
7 
8 print(dic)     　　　　　　　　　　# 执行报错，效果同上。

这题应该这么做，先将含有k的键值对，添加到列表，然后循环列表，删除字典的Key：*****

 1 dic = {\'k1\':\'value1\',\'k2\':\'value2\',\'name\':\'summer\'}
 2 
 3 li = []
 4 for i in dic:
 5     if \'k\' in i:
 6         li.append(i)
 7 
 8 for i in li:
 9     dic.pop(i)
10  
11 print(dic)    #{\'name\': \'wusir\'}

总结：在循环列表或者字典的时候，千万不要做添加或者删除操作。

2、字典的增删改查

增

第一种：用key进行定位，用=进行重新赋值：字典中不存在这个key时，增加这个key到字典中，字典中本来就存在这个key时，就修改这个key对应的value

1 dic = {\'name\': \'summer\', \'age\': 21}
2 dic[\'hobby\'] = \'skiing\'
3 print(dic)          # {\'age\': 21, \'hobby\': \'skiing\', \'name\': \'summer\'}

第二种： setdefault(key,value)：无则添加，有则不变

value可以省略，默认添加None。

1 dic = {\'name\': \'summer\', \'age\': 21}
2 dic.setdefault(\'hobby\')
3 print(dic)          # {{\'name\': \'summer\', \'age\': 21, \'hobby\': None}

添加键值对

1 dic = {\'name\': \'summer\', \'age\': 21}
2 dic.setdefault(\'hobby\',\'skiing\')
3 print(dic)          # {\'name\': \'summer\', \'age\': 21, \'hobby\': \'skiing\'}

添加一个已经存在的key

1 dic = {\'name\': \'summer\', \'age\': 21}
2 dic.setdefault(\'name\',\'spring\')
3 print(dic)          # {\'name\': \'summer\', \'age\': 21}

上述2个添加的方法，只能一个个添加。

删

① pop() 删除指定的key。pop()是所有方法中，唯一有返回值的。

删除指定的key

dic = {\'name\': \'summer\', \'age\': 21}
print(dic.pop(\'age\'))           # 21
print(dic)          # {\'name\': \'summer\'}

删除一个不存在的key

1 dic = {\'name\': \'summer\', \'age\': 21}
2 print(dic.pop(\'hobby\'))
3 print(dic)          # 报错KeyError: \'hobby\'

删除一个不存在的key，并指定默认返回值None

1 dic = {\'name\': \'summer\', \'age\': 21}
2 print(dic.pop(\'hobby\',None)) # None
3 print(dic)          # {\'name\': \'summer\', \'age\': 21}

推荐使用上述方法，删除一个key。因为如果key不存在时，不会报错，返回None。程序员最怕报错了！

② clear() 清空

1 dic = {\'name\': \'summer\', \'age\': 21}
2 dic.clear()
3 print(dic)          # {}

③ del 删除字典

按照键删除，del dic[\'key\']。如果不存在，会报错

1 dic = {\'name\': \'summer\', \'age\': 21}
2 del dic[\'hobby\']

从内存上清空 del dic

1 dic = {\'name\': \'summer\', \'age\': 21}
2 del dic
3 print(dic)          # NameError: name \'dic\' is not defined

④ popitem() 随机删除，有返回值.

在python3.6之前，随机删除一个键值对；从python3.6开始，删除最后一个键值对

1 dic = {\'name\': \'summer\', \'age\': 21}
2 print(dic.popitem()) # (\'age\', 21)
3 print(dic)          # {\'name\': \'summer\'}

改

① 通过键和=进行修改，与增的用法相同

1 dic = {\'name\': \'summer\', \'age\': 21}
2 dic[\'name\'] = \'zhangsan\'
3 print(dic)          # {\'name\': \'zhangsan\', \'age\': 21}

② update()：

dic1.update(dic2)：将dic2中的所有键值对覆盖并添加到dic1中（键相同的覆盖，键不同的添加）

1 # 针对2个字典的修改
2 dic1 = {\'name\': \'summer\', \'age\': 21}
3 dic2 = {\'name\': \'spring\', \'hobby\': \'skiing\'}
4 
5 # 将dic键值对,覆盖并添加到dic2
6 dic1.update(dic2)
7 print(dic1)  # {\'name\': \'spring\', \'age\': 21, \'hobby\': \'skiing\'}
8 print(dic2)  # {\'name\': \'spring\', \'hobby\': \'skiing\'}

可以发现dic2没有改变，dic1改变了. update()修改原则,有相同的就覆盖，没有的就添加

查

① 通过key进行查找（与列表通过索引进行查询相似）

1 dic = {\'name\':\'summer\',\'age\':21}
2 print(dic[\'name\'])

1 通过value查询
2 
3 dic = {\'name\':\'summer\',\'age\':21}
4 print(dic[\'summer\']) # 执行报错： KeyError: \'xiao\'

字典只能通过key查询，不能通过value查询，否则报错

② get(k,None)：字典种有这个key的返回这个key对应的value，没有的话返回第二参数，第二参数可以不写，默认返回None

有这个key，返回这个key对应的value值

dic = {\'name\': \'summer\', \'age\': 21}
print(dic.get(\'name\'))                  # summer

查询一个不存在的key, 默认返回None

1 dic = {\'name\': \'summer\', \'age\': 21}
2 print(dic.get(\'hobby\'))             # None

查询一个不存在的key, 设置返回值

1 dic = {\'name\': \'summer\', \'age\': 21}
2 print(dic.get(\'hobby\',\'亲，木有这个字哦！\')) # 亲，木有这个字哦！

如果需要查询多个key，请使用for循环

1 dic = {\'name\': \'summer\', \'age\': 21}
2 for i in dic:
3     print(i)

执行输出：
age
Name

3. 字典的特殊使用方法.keys().values().items()

dic.keys( )

① 用于提取字典种的key值，返回值的类型是 dict_keys

1 dic = {\'name\':\'helen\',\'age\':18,\'sex\':\'women\'}
2 print(dic.keys(),type(dic.keys()))   # dict_keys([\'name\', \'age\', \'sex\']) <class \'dict_keys\'>

② 提取字典中的key值，并将其转化为列表 list(dic.keys())

1 dic = {\'name\':\'helen\',\'age\':18,\'sex\':\'women\'}
2 li = list(dic.keys())
3 
4 print(li)   # [\'name\', \'age\', \'sex\']

③ 与for结合使用：输出的就是字典里的key（按原来的数据类型）

1 dic = {\'name\': \'summer\', \'age\': 21}
2 
3 for i in dic.keys():
4     print(i)

执行输出：
age
Name

keys()方法输出的数据是一个特殊类型，它相当于把所有的key放到了一个容器里面。它类似于列表的容器，当它并不是列表。

dic.values()

① 用于提取字典中的value值，返回值的类型是 dict_values

1 dic = {\'name\':\'helen\',\'age\':18,\'sex\':\'women\'}
2 print(dic.values(), type(dic.values()))    # dict_values([\'helen\', 18, \'women\']) <class \'dict_values\'>

② 提取字典中的value值，并将其转化为列表 list(dic.values())

1 dic = {\'name\':\'helen\',\'age\':18,\'sex\':\'women\'}
2 li = list(dic.values())
3 print(li)         # [\'helen\', 18, \'women\']

③ 与for结合使用：输出的就是字典里的value（按原来的数据类型）

1 dic = {\'name\':\'helen\',\'age\':18,\'sex\':\'women\'}
2 
3 for i in dic.values():     
4     print(i)

输出结果是：
helen
18
Women

dic.items()

① 用于提取字典种的key和value值，并将key和它对应的value用元组包围起来，返回值的类型是 dict_items

1 dic = {\'name\': \'helen\', \'age\': 18, \'sex\': \'women\'}
2 print(dic.items(), type(dic.items()))       # dict_items([(\'name\', \'helen\'), (\'age\', 18), (\'sex\', \'women\')]) <class \'dict_items\'>

② 提取字典中的key和value值，并将其转化为列表 list(dic.items())，其中key和它对应的value用元组包围起来[(key,value),(key,value),.....]

1 dic = {\'name\': \'helen\', \'age\': 18, \'sex\': \'women\'}
2 li = list(dic.items())
3 print(li)                   # [(\'name\', \'helen\'), (\'age\', 18), (\'sex\', \'women\')]

③ 与for结合使用：输出的就是字典里的key和value（按原来的数据类型）

I. for k,v in dic.items() :输出原始格式的key和value

dic = {\'name\': \'helen\', \'age\': 18, \'sex\': \'women\'}

for k,v in dic.items():
    print(k,v)

输出结果
 name helen
 age 18
 sex women

II. for i in dic.items() ：输出被元组包围的key和value

dic = {\'name\': \'helen\', \'age\': 18, \'sex\': \'women\'}

for i in dic.items():           
    print(i)   

输出结果
(\'name\', \'helen\')
(\'age\', 18)
(\'sex\', \'women\')

III. for i in dic() ：输出原始格式的key

dic = {\'name\': \'helen\', \'age\': 18, \'sex\': \'women\'}

for i in dic:
    print(i)

输出结果
 name
 age
 sex

4、字典的嵌套

dic = {\'name_list\': [\'王双\', \'alex\', \'孙飞\', \'taibai\'],
       1: {\'name\': \'taibai\', \'age\': 18, \'sex\': \'男\'},
       (1,2): [100, {\'ip\': \'192.168.1.1\', \'port\': 3306}]
       }

1,给 name_list对应的列表追加一个值: 司徒大人.
dic[\'name_list\'].append(\'司徒大人\')
print(dic)

2,将name_lsit对应的alex 变成全部大写. # 注意重新赋值
dic[\'name_list\'][1]=dic[\'name_list\'][1].upper()
print(dic)

3, 将1对应的字典添加一个键值对: weight : 75
dic[1][\'weight\'] = 75
print(dic)

4,将1 对应的字典的name键对应的名字taibai 换成alex
dic[1][\'name\'] = \'alex\'
print(dic)

5,将 {\'ip\': \'192.168.1.1\', \'port\': 3306} 次字典的port键值对删除.
dic[(1,2)][1].pop(\'port\')
print(dic)

注意：取键的时候，键是什么就写什么，并不是所有的键都是字符串，根据类型来看，是否需要加引号需要

七、集合

set1 = {1,2,’summer‘,(3,4)}

集合里面的元素必须是不可变的，只能是数字、字符串、bool值、元组，但是集合本身是可变的数据类型，集合里面的元素不能重复，集合是无序的。

1. 集合的创建

set1 = { }

set1 = set( { } )

2.集合常用操作 增删查

增

add()

1 set1 = {\'summer\',\'spring\'}
2 set1.add(\'winter\')
3 print(set1) #  {\'spring\', \'summer\', \'winter\'}

update() 迭代的增加

1 set1 = {\'summer\',\'spring\'}
2 set1.update(\'abc\')
3 print(set1) #  {\'c\', \'b\', \'summer\', \'a\', \'spring\'}

删

pop() 随机删除，pop() 是有返回值的

1 set1 = {\'summer\',\'spring\'}
2 print(set1.pop()) #  summer
3 print(set1) #  {{\'spring\'}

remove() 删除一个元素

1 set1 = {\'summer\',\'spring\'}
2 set1.remove(\'summer\')
3 print(set1) #  {{\'spring\'}

clear() 清空集合

1 set1 = {\'summer\',\'spring\'}
2 set1.clear()
3 print(set1) # set()

del 删除集合

1 set1 = {\'summer\',\'spring\'}
2 del set1
3 print(set1) # NameError: name \'set1\' is not defined

改

集合无改的方法

查

查只能for循环

1 set1 = {\'summer\',\'spring\'}
2 for i in set1:
3     print(i)

3. 集合作用

1）列表去重：直接转换为集合，就可以

1 li = [11,11,22,22,33,33,33,44]
2 li = list(set(li))
3 
4 print(li)     # [33, 11, 44, 22]

2）关系测试

交集( &或者intersection)

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

print(set1 & set2)
print(set1.intersection(set2))

 
执行输出：
{4, 5}
{4, 5}

并集( |或union)

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

print(set1 | set2)
print(set1.union(set2))


执行输出：
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3, 4, 5, 6, 7, 8}

反交集( ^或 symmetric_difference)。和交集，取反的结果，也就是说，删除相同的，保留不同的。

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

print(set1 ^ set2)
print(set1.symmetric_difference(set2))


执行输出：
{1, 2, 3, 6, 7, 8}
{1, 2, 3, 6, 7, 8}

差集( - 或difference)

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

print(set1 - set2)
print(set1.difference(set2))

 
执行输出：
{1, 2, 3}
{1, 2, 3}

子集(issubset)

判断一个集合是否被另外一个集合包含

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set1.issubset(set2)) 　　　　　　# True

超集(issuperset)

判断一个集合是否包含另外一个集合

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set2.issuperset(set1)) # True

集合关系测试，记符合就可以了，英文字母太长了，不好记。

frozenset()将集合转换为可哈希的类型，可以作为字典的key

set1 = {\'summer\',\'spring\'}
set2 = frozenset(set1)

print(set2) # frozenset({\'summer\', \'spring\'})