引子

	数据类型是用来记录事物状态的，而事物的状态是不断变化的(如:一个人年龄的增长（操作int类型） ，单个人名的修改（操作str类型），学生列表中增加学生（操作list类型）等)，这意味着我们在开发程序时需要频繁对数据进行操作，为了提升我们的开发效率， python针对这些常用的操作，为每一种数据类型内置了一系列方法。本章的主题就是带大家详细了解下它们，以及每种数据类型的详细定义、类型转换。

数字类型（int与float）

定义

# 1、定义：
# 1.1 整型int的定义
age=10  # 本质age = int(10)

# 1.2 浮点型float的定义
salary=3000.3  # 本质salary=float(3000.3)

# 注意：名字+括号的意思就是调用某个功能，比如
# print(...)调用打印功能
# int(...)调用创建整型数据的功能
# float(...)调用创建浮点型数据的功能

类型转换

# 1、数据类型转换
# 1.1 int可以将由纯整数构成的字符串直接转换成整型，若包含其他任意非整数符号，则会报错
s = '123'
res = int(s)
print(res,type(res))  # 123, <class 'int'>
print(int('12.3')) # 错误演示：字符串内包含了非整数符号.
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '12.3'

# 1.2 进制转换
# 十进制转其他进制
print(bin(3))
'0b11'
print(oct(9))
'0o11'
print(hex(17))
'0x11'
# 其他进制转十进制
print(int('0b11',2))  #3
print(int('0o11',8))  #9
print(int('0x11',16))  #17

# 1.3 float同样可以用来做数据类型的转换
>>> s = '12.3'
>>> res=float(s)
>>> res,type(res)
(12.3, <class 'float'>)

内置方法(int)（了解操作）

int.bit_length()

  - 返回整数的二进制表示中最高位的位数，不包括符号和前导零。
num = 42
bit_length = num.bit_length()
print(bit_length)
# 输出：6
```

int.to_bytes(length, byteorder, signed)

  - 将整数转换为字节数组。
  - 参数`length`指定生成的字节数组的长度，`byteorder`指定字节顺序，`signed`指定是否考虑整数的符号。
num = 42
byte_array = num.to_bytes(2, byteorder='big', signed=False)
print(byte_array)
# 输出：b'\x00*'
```

int.from_bytes(bytes, byteorder, signed)

  - 将字节数组转换为整数。
  - 参数`bytes`是输入的字节数组，`byteorder`指定字节顺序，`signed`指定是否考虑整数的符号。
byte_array = b'\x00*'
num = int.from_bytes(byte_array, byteorder='big', signed=False)
print(num)
# 输出：42
```

int.__add__(other)

  - 实现整数的加法运算。
num1 = 42
num2 = 10
result = num1.__add__(num2)
print(result)
# 输出：52
```

int.__sub__(other)

  - 实现整数的减法运算。
num1 = 42
num2 = 10
result = num1.__sub__(num2)
print(result)
# 输出：32
```

int.__mul__(other)

  - 实现整数的乘法运算。
num1 = 42
num2 = 10
result = num1.__mul__(num2)
print(result)
# 输出：420
```

int.__truediv__(other)

  - 实现整数的真除法运算。
num1 = 42
num2 = 10
result = num1.__truediv__(num2)
print(result)
# 输出：4.2
```

int.__floordiv__(other)

  - 实现整数的整除法运算。
num1 = 42
num2 = 10
result = num1.__floordiv__(num2)
print(result)
# 输出：4
```

int.__mod__(other)
    
  - 实现整数的取模运算。
num1 = 42
num2 = 10
result = num1.__mod__(num2)
print(result)
# 输出：2
```

int.__pow__(other, modulo=None)

  - 实现整数的幂运算。
num1 = 2
num2 = 3
result = num1.__pow__(num2)
print(result)
# 输出：8

内置方法(float)（了解操作）

- 浮点类型的内置方法包括各种数学运算，例如加法、减法、乘法和除法。
- 此外，还有一些与浮点数相关的函数，如取整函数 round()。
# 加法
result_add = 3.14 + 2.5

# 减法
result_subtract = 5.7 - 1.2

# 乘法
result_multiply = 2.0 * 3.5

# 除法
result_divide = 8.0 / 4.0

# 取整
rounded_number = round(3.14159)
- 这些方法和运算符都可用于浮点数的处理。值得注意的是，由于计算机存储浮点数的方式，可能存在一些精度问题。

补充：判断数字类型

数字类型说明

num1 = b'4'  # bytes
num2 = '4'   # unicode，Python 3 中不需要在字符串前加 'u'
num3 = '四'  # 中文数字
num4 = 'Ⅳ'   # 罗马数字

1. 判断数字类型(isdigit)

# isdigit: bytes, unicode
print(num1.isdigit())  # True
print(num2.isdigit())  # True
print(num3.isdigit())  # False
print(num4.isdigit())  # False

2.判断小数类型(isdecimal)

# isdecimal: unicode（bytes 类型没有 isdecimal 方法）
print(num2.isdecimal())  # True
print(num3.isdecimal())  # False
print(num4.isdecimal())  # False

3.判断数字类型(isnumeric)

# isnumeric: unicode, 中文数字, 罗马数字（bytes 类型没有 isnumeric 方法）
print(num2.isnumeric())  # True
print(num3.isnumeric())  # True
print(num4.isnumeric())  # True

4.无法判断浮点数

# 这三种方法无法判断浮点数
num5 = '4.3'
print(num5.isdigit())    # False
print(num5.isdecimal())  # False
print(num5.isnumeric())  # False

字符串类型（str）

定义

# 定义：在单引号\双引号\三引号内包含一串字符
name1 = 'xiao'  # 本质:name = str('任意形式内容')
name2 = "lili"  # 本质:name = str("任意形式内容")
name3 = """ricky"""  # 本质:name = str("""任意形式内容""")

类型转换

# 数据类型转换：str()可以将任意数据类型转换成字符串类型，例如 
>>> type(str([1,2,3])) # list->str
<class 'str'>
>>> type(str({"name":"xiao","age":18})) # dict->str
<class 'str'>
>>> type(str((1,2,3)))  # tuple->str
<class 'str'>
>>> type(str({1,2,3,4})) # set->str
<class 'str'>

内置方法（优先掌握）

str1 = 'hello python!'

# 1.按索引取值(正向取，反向取)：
# 1.1 正向取(从左往右)
>>> str1[6]
p
# 1.2 反向取(负号表示从右往左)
>>> str1[-4]
h
# 1.3 对于str来说，只能按照索引取值，不能改值
>>> str1[0]='H' # 报错TypeError


# 2.切片(顾头不顾尾，步长)
# 2.1 顾头不顾尾：取出索引为0到8的所有字符
>>> str1[0:9]  
hello pyt
# 2.2 步长：0:9:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2、4、6、8的字符
>>> str1[0:9:2]  
hlopt 
# 2.3 反向切片
>>> str1[::-1]  # -1表示从右往左依次取值
!nohtyp olleh

# 3.长度len
# 3.1 获取字符串的长度，即字符的个数，但凡存在于引号内的都算作字符)
>>> len(str1) # 空格也算字符
13

# 4.成员运算 in 和 not in    
# 4.1 int:判断hello 是否在 str1里面
>>> 'hello' in str1  
True
# 4.2 not in:判断tony 是否不在 str1里面
>>> 'tony' not in str1 
True

# 5.strip移除字符串首尾指定的字符(默认移除空格)
# 5.1 括号内不指定字符，默认移除首尾空白字符(空格、\n、\t)
>>> str1 = '  life is short!  '
>>> str1.strip()  
life is short!

# 5.2 括号内指定字符，移除首尾指定的字符
>>> str2 = '**tony**'  
>>> str2.strip('*')  
tony

# 6.切分split
# 6.1 括号内不指定字符，默认以空格作为切分符号
>>> str3='hello world'
>>> str3.split()
['hello', 'world']
# 6.2 括号内指定分隔字符，则按照括号内指定的字符切割字符串
str4 = '127.0.0.1'
print (str4.split('.'))  
['127', '0', '0', '1']  # 注意:split切割得到的结果是列表数据类型


# 7.循环
 str5 = '今天是晴天!'
 for line in str5:  # 依次取出字符串中每一个字符
 print(line)

今
天
是
晴
天
！

内置方法（需要掌握）

1.strip, lstrip, rstrip  （去除空格(strip)或者指定字符）
text = '**Hello, World!**'

stripped_text = text.strip()  # 移除左右两边的指定字符
print(stripped_text)  # Hello, World!

left_stripped_text = text.lstrip()  # 移除左右两边的指定字符
print(left_stripped_text)  # Hello, World!**

right_stripped_text = text.rstrip()  # 移除右边的指定字符
print(right_stripped_text)  # **Hello, World!

2.lower(),upper()  （大小写转换）
text = 'hello'
uppercase_text = text.upper()  # 将英文字符串全部变大写
print(uppercase_text)  # 输出: HELLO

text = 'WORLD'
lowercase_text = text.lower()  # 将英文字符串全部变小写
print(lowercase_text)  # 输出: world

3.startswith,endswith  （首尾字符判断）
text = 'Python is fun'
# startswith()判断字符串是否以括号内指定的字符开头，结果为布尔值True或False
result = text.startswith('Python')
print(result)
# 输出: True

# endswith()判断字符串是否以括号内指定的字符结尾，结果为布尔值True或False
result = text.endswith('fun')
print(result)
# 输出: True

4.格式化输出之format

之前我们使用%s来做字符串的格式化输出操作，在传值时，必须严格按照位置与%s一一对应，而字符串的内置方法format则提供了一种不依赖位置的传值方式

案例：

# format括号内在传参数时完全可以打乱顺序，但仍然能指名道姓地为指定的参数传值，name=‘tony’就是传给{name}
>>> str4 = 'my name is {name}, my age is {age}!'.format(age=18,name='tony')
>>> str4  
'my name is tony, my age is 18!'

>>> str4 = 'my name is {name}{name}{name}, my age is {name}!'.format(name='tony', age=18)
>>> str4  
'my name is tonytonytony, my age is tony!'
format的其他使用方式（了解）

# 类似于%s的用法，传入的值会按照位置与{}一一对应
>>> str4 = 'my name is {}, my age is {}!'.format('tony', 18)
>>> str4 
my name is tony, my age is 18!
# 把format传入的多个值当作一个列表，然后用{索引}取值
>>> str4 = 'my name is {0}, my age is {1}!'.format('tony', 18)
>>> str4
my name is tony, my age is 18!

>>> str4 = 'my name is {1}, my age is {0}!'.format('tony', 18)
>>> str4  
my name is 18, my age is tony!

>>> str4 = 'my name is {1}, my age is {1}!'.format('tony', 18)
>>> str4  
my name is 18, my age is 18!

5.split,rsplit
# split会按照从左到右的顺序对字符串进行切分，可以指定切割次数
>>> str5='C:/a/b/c/d.txt'
>>> str5.split('/',1)
['C:', 'a/b/c/d.txt']  

# rsplit刚好与split相反，从右往左切割，可以指定切割次数
>>> str5='a|b|c'
>>> str5.rsplit('|',1)
['a|b', 'c']
6.join

# 从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串
>>> '%'.join('hello') # 从字符串'hello'中取出多个字符串，然后按照%作为分隔符号进行拼接
'h%e%l%l%o'
>>> '|'.join(['tony','18','read'])  # 从列表中取出多个字符串，然后按照*作为分隔符号进行拼接
'tony|18|read'
7.replace

# 用新的字符替换字符串中旧的字符
>>> str7 = 'my name is tony, my age is 18!'  # 将tony的年龄由18岁改成73岁
>>> str7 = str7.replace('18', '73')  # 语法:replace('旧内容', '新内容')
>>> str7
my name is tony, my age is 73!

# 可以指定修改的个数
>>> str7 = 'my name is tony, my age is 18!'
>>> str7 = str7.replace('my', 'MY',1) # 只把一个my改为MY
>>> str7
'MY name is tony, my age is 18!'
8.isdigit

# 判断字符串是否是纯数字组成，返回结果为True或False
>>> str8 = '5201314'
>>> str8.isdigit()
True

>>> str8 = '123g123'
>>> str8.isdigit()
False

内置方法（了解操作）

# 1.find,rfind,index,rindex,count  (查找)
# 1.1 find：从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1
>>> msg='tony say hello'
>>> msg.find('o',1,3)  # 在索引为1和2(顾头不顾尾)的字符中查找字符o的索引
1  
# 1.2 index:同find,但在找不到时会报错, 返回 -1
>>> msg.index('e',2,4) # 报错ValueError
# 1.3 rfind与rindex：略
# 1.4 count:统计字符串在大字符串中出现的次数
>>> msg = "hello everyone"
>>> msg.count('e')  # 统计字符串e出现的次数
4
>>> msg.count('e',1,6)  # 字符串e在索引1~5范围内出现的次数
1

# 2.center,ljust,rjust,zfill  （填充）
>>> name='tony'
>>> name.center(30,'-')  # 总宽度为30，字符串居中显示，不够用-填充，不均衡右多左少
-------------tony-------------
>>> name.ljust(30,'*')  # 总宽度为30，字符串左对齐显示，不够用*填充
tony**************************
>>> name.rjust(30,'*')  # 总宽度为30，字符串右对齐显示，不够用*填充
**************************tony
>>> name.zfill(50)  # 总宽度为50，字符串右对齐显示，不够用0填充
0000000000000000000000000000000000000000000000tony

# 3.expandtabs  （制表符）
>>> name = 'tony\thello'  # \t表示制表符(tab键)
>>> name
tony    hello
>>> name.expandtabs(1)  # 修改\t制表符代表的空格数
tony hello

# 4.captalize,swapcase,title
# 4.1 captalize：首字母大写
>>> message = 'hello everyone nice to meet you!'
>>> message.capitalize()
Hello everyone nice to meet you!  
# 4.2 swapcase：大小写翻转
>>> message1 = 'Hi girl, I want make friends with you!'
>>> message1.swapcase()  
hI GIRL, i WANT MAKE FRIENDS WITH YOU!  
#4.3 title：每个单词的首字母大写
>>> msg = 'dear my friend i miss you very much'
>>> msg.title()
Dear My Friend I Miss You Very Much 

# 5.is数字系列
#在python3中
num1 = b'4' #bytes
num2 = u'4' #unicode,python3中无需加u就是unicode
num3 = '四' #中文数字
num4 = 'Ⅳ' #罗马数字

#isdigt:bytes,unicode （判断数字类型）
>>> num1.isdigit()
True
>>> num2.isdigit()
True
>>> num3.isdigit()
False
>>> num4.isdigit() 
False

#isdecimal:uncicode(bytes类型无isdecimal方法)  （判断小数类型）
>>> num2.isdecimal() 
True
>>> num3.isdecimal() 
False
>>> num4.isdecimal() 
False

#isnumberic:unicode,中文数字,罗马数字(bytes类型无isnumberic方法) （判断数字类型）
>>> num2.isnumeric() 
True
>>> num3.isnumeric() 
True
>>> num4.isnumeric() 
True

# 三者不能判断浮点数
>>> num5 = '4.3'
>>> num5.isdigit()
False
>>> num5.isdecimal()
False
>>> num5.isnumeric()
False

'''
总结:
    最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
    如果要判断中文数字或罗马数字,则需要用到isnumeric。
    # 这三种方法无法判断浮点数
'''

# 6.is其他
>>> name = 'tony123'
>>> name.isalnum() #字符串中既可以包含数字也可以包含字母
True
>>> name.isalpha() #字符串中只包含字母
False
>>> name.isidentifier()
True
>>> name.islower()  # 字符串是否是纯小写
True
>>> name.isupper()  # 字符串是否是纯大写
False
>>> name.isspace()  # 字符串是否全是空格
False
>>> name.istitle()  # 字符串中的单词首字母是否都是大写
False

列表类型 （list）

定义

# 定义：在[]内,用逗号分隔开多个任意数据类型的值
l1 = [1,'a',[1,2]]  # 本质:l1 = list([1,'a',[1,2]])

类型转换

# 但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中
>>> list('wdad') # 结果：['w', 'd', 'a', 'd'] 
>>> list([1,2,3]) # 结果：[1, 2, 3]
>>> list({"name":"xiao","age":18}) #结果：['name', 'age']
>>> list((1,2,3)) # 结果：[1, 2, 3] 
>>> list({1,2,3,4}) # 结果：[1, 2, 3, 4]

内置方法（优先掌握）

# 1.按索引存取值(正向存取+反向存取)：即可存也可以取  
# 1.1 正向取(从左往右)
my_friends=['tony','xiao','tom',4,5]
print(my_friends[0])  #tony
# 1.2 反向取(负号表示从右往左)
print(my_friends[-1])  #5

# 1.3 对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错
my_friends = ['tony','jack','xiao',4,5]
print(my_friends[1]) = 'martthow'
print(my_friends)
['tony', 'martthow', 'xiao', 4, 5]


# 2.切片(顾头不顾尾，步长)
# 2.1 顾头不顾尾：取出索引为0到3的元素
print(my_friends[0:4]) 
['tony', 'xiao', 'tom', 4]
# 2.2 步长：0:4:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素
print(my_friends[0:4:2])
['tony', 'tom']

# 3.长度
print(len(my_friends))
5

# 4.成员运算in和not in
print('tony' in my_friends)
True
print('tonc' not in my_friends)
True


# 5.添加
# 5.1 append()列表尾部追加元素
l1 = ['a','b','c']
l1.append('d')
print(l1)
['a', 'b', 'c', 'd']

# 5.2 extend()一次性在列表尾部添加多个元素， 参数必须是列表、集合或者元组
l1.extend(['a','b','c'])
print(l1)
['a', 'b', 'c', 'd', 'a', 'b', 'c']

# 5.3 insert()在指定位置插入元素
l1.insert(0,"first")  # 0表示按索引位置插值
print(l1)
['first', 'a', 'b', 'c', 'alisa', 'a', 'b', 'c']

# 6.删除
# 6.1 del
l = [11,22,33,44]
del l[2]  # 删除索引为2的元素
print(l)
[11,22,44]

# 6.2 pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
l = [11,22,33,22,44]
res=l.pop()
print(res)
44
res=l.pop(1)
print(res)
22

# 6.3 remove()括号内指名道姓表示要删除哪个元素，没有返回值
l = [11,22,33,22,44]
res=l.remove(22) # 从左往右查找第一个括号内需要删除的元素
print(res)
None

# 7.reverse()颠倒列表内元素顺序
l = [11,22,33,44]
l.reverse() 
print(l)
[44,33,22,11]

# 8.sort()给列表内所有元素排序
# 8.1 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
l = [11,22,3,42,7,55]
l.sort()
print(l) 
[3, 7, 11, 22, 42, 55]  # 默认从小到大排序
l = [11,22,3,42,7,55]
l.sort(reverse=True)  # reverse用来指定是否跌倒排序，默认为False
print(l) 
[55, 42, 22, 11, 7, 3]
# 8.2 了解知识：
# 我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如
l1=[1,2,3]
l2=[2,]
print(l2 > l1)
True
# 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大
s1='abc'
s2='az'
print(s2 > s1) # s1与s2的第一个字符没有分出胜负，但第二个字符'z'>'b',所以s2>s1成立
True
# 所以我们也可以对下面这个列表排序
l = ['A','z','adjk','hello','hea']
l.sort()
print(l)
['A', 'adjk', 'hea', 'hello','z']

# 8.3 元素排序(sorted())
- 需要注意的是，sort() 方法会直接修改原列表，而不会返回一个新的排序后的列表。
- 如果你需要保留原列表，可以使用 sorted() 函数

# 示例
numbers = [5, 2, 9, 1, 7]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出: [1, 2, 5, 7, 9]
print(numbers)  # 输出: [5, 2, 9, 1, 7]

- sort() 方法默认是按照元素的大小进行排序，如果需要自定义排序规则，可以使用 key 参数，传入一个函数
- 例如，按照元素的绝对值进行排序：

# 示例
numbers = [-5, 2, -9, 1, 7]
numbers.sort(key=abs)
print(numbers)  # 输出: [1, 2, -5, 7, -9]
- key 参数指定的函数将应用于列表中的每个元素，用于提取排序的关键字。

# 9.循环
# 循环遍历my_friends列表里面的值
for line in my_friends:
    print(line) 
'tony'
'jack'
'xiao'
4
5

内置方法（了解操作）

l=[1,2,3,4,5,6]
print(l[0:3:1])
[1, 2, 3]  # 正向步长
print([2::-1]) 
[3, 2, 1]  # 反向步长

# 通过索引取值实现列表翻转
print(l[::-1])
[6, 5, 4, 3, 2, 1]

元组类型 （tuple）

元组与列表类似，也是可以存多个任意类型的元素，不同之处在于元组的元素不能修改，即元组相当于不可变的列表，用于记录多个固定不允许修改的值，单纯用于取

定义

# 在()内用逗号分隔开多个任意类型的值
countries = ("中国"，"美国"，"英国")  # 本质:countries = tuple("中国"，"美国"，"英国")
# 强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组
countries = ("中国"，)  # 本质:countries = tuple("中国")

类型转换

# 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
print(tuple('wdad')) # 结果：('w', 'd', 'a', 'd') 
print(tuple([1,2,3])) # 结果：(1, 2, 3)
print(tuple({"name":"xiao","age":18})) # 结果：('name', 'age')
print(tuple((1,2,3))) # 结果：(1, 2, 3)
print(tuple({1,2,3,4})) # 结果：(1, 2, 3, 4)
# tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中

内置方法

tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33) 
# 1、按索引取值(正向取+反向取)：只能取，不能改否则报错！  
print(tuple1[0])
1
print(tuple1[-2])
22
tuple1[0] = 'hehe'  # 报错：TypeError:

# 2、切片(顾头不顾尾，步长)
print(tuple1[0:6:2])
(1, 15000.0, 22)

# 3、长度
print(len(tuple1)) 
6

# 4、成员运算 in 和 not in
print('hhaha' in tuple1)
True
print('hhaha' not in tuple1)  
False 

# 5、循环
for line in tuple1:
...     print(line)
1
hhaha
15000.0
11
22
33

字典类型 （dict）

定义

# 定义：在{}内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key则必须是不可变类型，详见第八小节，通常key应该是str类型，因为str类型会对value有描述性的功能
info={'name':'tony','age':18,'sex':'male'} #本质info=dict({....})
# 也可以这么定义字典
info=dict(name='tony',age=18,sex='male') # info={'age': 18, 'sex': 'male', 'name': 'tony'}

类型转换

# 转换1: 
info = dict([['name','tony'],('age',18)])
print(info)
{'age': 18, 'name': 'tony'}

# 转换2：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
{}.fromkeys(('name','age','sex'),None)  
{'age': None, 'sex': None, 'name': None}

内置方法（优先掌握）

# 1、按key存取值：可存可取
# 1.1 取
dic = {
...     'name': 'xxx',
...     'age': 18,
...     'hobbies': ['play game', 'basketball']
... }
print(dic['name'])
'xxx'
print(dic['hobbies'][1])
'basketball'
# 1.2 对于赋值操作，如果key原先不存在于字典，则会新增key:value
dic['gender'] = 'male'  
print(dic)
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball'],'gender':'male'}
# 1.3 对于赋值操作，如果key原先存在于字典，则会修改对应value的值
dic['name'] = 'tony'
print(dic)
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}


# 2、长度len
print(len(dic))
3


# 3、成员运算in和not in
print('name' in dic)  # 判断某个值是否是字典的key
True


# 4、删除
dic.pop('name')  # 通过指定字典的key来删除字典的键值对
print(dic)
{'age': 18, 'hobbies': ['play game', 'basketball']}


# 5、键keys()，值values()，键值对items()
dic = {'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}
# 获取字典所有的key
>>> dic.keys()  
dict_keys(['name', 'age', 'hobbies'])
# 获取字典所有的value
>>> dic.values()
dict_values(['xxx', 18, ['play game', 'basketball']])
# 获取字典所有的键值对
>>> dic.items()
dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])


# 6、循环
# 6.1 默认遍历的是字典的key
>>> for key in dic:
...     print(key)
... 
age
hobbies
name
# 6.2 只遍历key
>>> for key in dic.keys():
...     print(key)
... 
age
hobbies
name
# 6.3 只遍历value
>>> for key in dic.values():
...     print(key)
... 
18
['play game', 'basketball']
xxx
# 6.4 遍历key与value
>>> for key in dic.items():
...     print(key)
... 
('age', 18)
('hobbies', ['play game', 'basketball'])
('name', 'xxx')

# 7、 字典排序(sorted())
- 字典的排序是通过字典的键来进行的，使用 sorted() 函数可以对字典进行排序。
# 示例
my_dict = {'apple': 5, 'banana': 2, 'orange': 8, 'grape': 1}

# 对字典按键排序，并返回一个列表
sorted_dict = sorted(my_dict.items())
print(sorted_dict)
# 输出: [('apple', 5), ('banana', 2), ('grape', 1), ('orange', 8)]

- 在示例中，sorted() 函数对字典 my_dict 的键进行了排序，返回了一个按键排序的元组列表。
- 如果需要按值进行排序，可以使用 key 参数指定排序的关键字：
# 示例
my_dict = {'apple': 5, 'banana': 2, 'orange': 8, 'grape': 1}

# 对字典按值排序，并返回一个列表
sorted_dict = sorted(my_dict.items(), key=lambda x: x[1])
print(sorted_dict)
# 输出: [('grape', 1), ('banana', 2), ('apple', 5), ('orange', 8)]

- 在这个示例中，key` 参数指定了按值排序，并使用了 lambda 函数提取元组中的第二个元素（值）作为排序的关键字。

内置方法（需要掌握）

1.get()

dic= {'k1':'xiao','k2':'Tony','k3':'JY'}
print(dic.get('k1'))
'xiao'  # key存在，则获取key对应的value值
res=dic.get('xxx') # key不存在，不会报错而是默认返回None
print(res)
None  
res=dic.get('xxx',666) # key不存在时，可以设置默认返回的值
print(res)
666 
# ps:字典取值建议使用get方法

2.pop()

dic= {'k1':'xiao','k2':'Tony','k3':'JY'}
v = dic.pop('k2')  # 删除指定的key对应的键值对,并返回值
print(dic)
{'k1': 'xiao', 'kk2': 'JY'}
print(v)
'Tony'

3.popitem()

dic= {'k1':'xiao','k2':'Tony','k3':'JY'}
item = dic.popitem()  # 删除结尾一组键值对,并将删除的键值放到元组内返回（python3.7之后）
print(dic)
{'k3': 'JY', 'k2': 'Tony'}
print(item)
('k1', 'xiao')

4.update()

# 用新字典更新旧字典，有则修改，无则添加
dic= {'k1':'xiao','k2':'Tony','k3':'JY'}
dic.update({'k1':'JN','k4':'xxx'})
print(dic)
{'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}

5.fromkeys()

dic = dict.fromkeys(['k1','k2','k3'],[])
print(dic)
{'k1': [], 'k2': [], 'k3': []}

6.setdefault()

# key不存在则新增键值对，并将新增的value返回
dic={'k1':111,'k2':222}
res=dic.setdefault('k3',333)
print(res)
333
print(dic) # 字典中新增了键值对
{'k1': 111, 'k3': 333, 'k2': 222}

# key存在则不做任何修改，并返回已存在key对应的value值
dic={'k1':111,'k2':222}
res=dic.setdefault('k1',666)
print(res)
111
print(dic) # 字典不变
{'k1': 111, 'k2': 222}

集合

集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算

定义

"""
定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：
     1：每个元素必须是不可变类型
     2：集合内没有重复的元素
     3：集合内元素无序
"""
s = {1,2,3,4}  # 本质 s = set({1,2,3,4})

# 注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。

# 注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，现在我们想定义一个空字典和空集合，该如何准确去定义两者?
d = {} # 默认是空字典 
s = set() # 这才是定义空集合

类型转换

# 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型
>>> s = set([1,2,3,4])
>>> s1 = set((1,2,3,4))
>>> s2 = set({'name':'xiao',})
>>> s3 = set('xu')
>>> print(s,s1,s2,s3)
{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'x', 'u'}

内置方法

1. 关系运算 （集合的交并差）

我们定义两个集合friends与friends2来分别存放两个人的好友名字，然后以这两个集合为例讲解集合的关系运算

 friends1 = {"zero","kevin","xiao","xu"} # 用户1的好友们 
 friends2 = {"Jy","ricky","xiao","xu"}   # 用户2的好友们

两个集合的关系如下图所示

# 1.合集/并集(|)：求两个用户所有的好友（重复好友只留一个）
>>> friends1 | friends2
{'kevin', 'ricky', 'zero', 'xiao', 'Jy', 'xu'}

# 2.交集(&)：求两个用户的共同好友
>>> friends1 & friends2
{'xiao', 'xu'}

# 3.差集(-)：
>>> friends1 - friends2 # 求用户1独有的好友
{'kevin', 'zero'}
>>> friends2 - friends1 # 求用户2独有的好友
{'ricky', 'Jy'}

# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
>>> friends1 ^ friends2
{'kevin', 'zero', 'ricky', 'Jy'}

# 5.值是否相等(==)
>>> friends1 == friends2
False

# 6.父集：一个集合是否包含另外一个集合
# 6.1 包含则返回True
>>> {1,2,3} > {1,2}
True
>>> {1,2,3} >= {1,2}
True
# 6.2 不存在包含关系，则返回False
>>> {1,2,3} > {1,3,4,5}
False
>>> {1,2,3} >= {1,3,4,5}
False

# 7.子集
>>> {1,2} < {1,2,3}
True
>>> {1,2} <= {1,2,3}
True

2. 去重

集合去重复有局限性

# 1. 只能针对不可变类型
# 2. 集合本身是无序的，去重之后无法保留原来的顺序

示例如下

l=['a','b',1,'a','a']
s=set(l)
print(s) # 将列表转成了集合
{'b', 'a', 1}
l_new=list(s) # 再将集合转回列表
print(l_new)
['b', 'a', 1] # 去除了重复，但是打乱了顺序

# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
l=[
    {'name':'lili','age':18,'sex':'male'},
    {'name':'jack','age':73,'sex':'male'},
    {'name':'tom','age':20,'sex':'female'},
    {'name':'lili','age':18,'sex':'male'},
    {'name':'lili','age':18,'sex':'male'},
]

new_l=[]

for dic in l:
    if dic not in new_l:
        new_l.append(dic)
print(new_l)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
[
    {'age': 18, 'sex': 'male', 'name': 'lili'}, 
    {'age': 73, 'sex': 'male', 'name': 'jack'}, 
    {'age': 20, 'sex': 'female', 'name': 'tom'}
]

3. 其他操作

# 1.长度
s={'a','b','c'}
print(len(s))
3

# 2.成员运算
'c' in s
True

# 3.循环
for item in s:
...     print(item)
... 
c
a
b

### （1）添加元素
#### [1] 添加单个元素(add())
- add(element) 方法用于向集合中添加单个元素。
# 示例
my_set = {1, 2, 3}
my_set.add(4)
print(my_set)  # 输出: {1, 2, 3, 4}


#### [2]添加多个元素(update())
- update(iterable) 方法用于向集合中添加多个元素，参数是一个可迭代对象。
# 示例
my_set = {1, 2, 3}
my_set.update([3, 4, 5])
print(my_set)  # 输出: {1, 2, 3, 4, 5}


### （2）删除元素
#### [1] 删除指定元素(remove())

- remove(element) 方法用于移除集合中的指定元素，如果元素不存在则会引发 KeyError。
# 示例
my_set = {1, 2, 3, 4, 5}
my_set.remove(3)
print(my_set)  # 输出: {1, 2, 4, 5}


#### [2] 删除指定元素(discard())

- discard(element) 方法用于移除集合中的指定元素，如果元素不存在则不会引发错误。
# 示例
my_set = {1, 2, 3, 4, 5}
my_set.discard(3)
print(my_set)  # 输出: {1, 2, 4, 5}


#### [3] 随机删除元素(pop())

- pop() 方法用于随机移除集合中的一个元素，如果集合为空则引发 KeyError。（集合输出的第一个元素删掉）
# 示例
my_set = {1, 2, 3, 4, 5}
removed_element = my_set.pop()
print(removed_element)  # 输出: 随机移除的元素
print(my_set)           # 输出: 移除后的集合

数据类型总结