python中级之数据类型内置方法

11.python中级之数据类型内置方法2023-12-03

引子

 	数据类型是用来记录事物状态的，而事物的状态是不断变化的(如:一个人年龄的增长（操作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)
print(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 正向取(从左往右)
print(str1[6])
p
# 1.2 反向取(负号表示从右往左)
print(str1[-4])
h
# 1.3 对于str来说，只能按照索引取值，不能改值
print(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 获取字符串的长度，即字符的个数，但凡存在于引号内的都算作字符)
print(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!  '
print(str1.strip())  
life is short!
 
# 5.2 括号内指定字符，移除首尾指定的字符
str2 = '**tony**'  
print(str2.strip('*'))  
tony
 
# 6.切分split
# 6.1 括号内不指定字符，默认以空格作为切分符号
str3='hello world'
print(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')
print(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)
print(str4)
'my name is tonytonytony, my age is tony!'
format的其他使用方式（了解）
 
# 类似于%s的用法，传入的值会按照位置与{}一一对应
str4 = 'my name is {}, my age is {}!'.format('tony', 18)
print(str4)
my name is tony, my age is 18!
# 把format传入的多个值当作一个列表，然后用{索引}取值
str4 = 'my name is {0}, my age is {1}!'.format('tony', 18)
print(str4)
my name is tony, my age is 18!
 
str4 = 'my name is {1}, my age is {0}!'.format('tony', 18)
print(str4)
my name is 18, my age is tony!
 
str4 = 'my name is {1}, my age is {1}!'.format('tony', 18)
print(str4)
my name is 18, my age is 18!
 
5.split,rsplit
# split会按照从左到右的顺序对字符串进行切分，可以指定切割次数
str5='C:/a/b/c/d.txt'
print(str5.split('/',1))
['C:', 'a/b/c/d.txt']  
 
# rsplit刚好与split相反，从右往左切割，可以指定切割次数
str5='a|b|c'
print(str5.rsplit('|',1))
['a|b', 'c']
 
6.join
# 从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串
print('%'.join('hello')) # 从字符串'hello'中取出多个字符串，然后按照%作为分隔符号进行拼接
'h%e%l%l%o'
print('|'.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('旧内容', '新内容')
print(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'
print(str8.isdigit())
True
 
str8 = '123g123'
print(str8.isdigit())
False

内置方法（了解操作）

 # 1.find,rfind,index,rindex,count  (查找)
# 1.1 find：从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1
msg='tony say hello'
print(msg.find('o',1,3))  # 在索引为1和2(顾头不顾尾)的字符中查找字符o的索引
1  
# 1.2 index:同find,但在找不到时会报错, 返回 -1
print(msg.index('e',2,4)) # 报错ValueError
# 1.3 rfind与rindex：略
# 1.4 count:统计字符串在大字符串中出现的次数
msg = "hello everyone"
print(msg.count('e'))  # 统计字符串e出现的次数
4
print(msg.count('e',1,6))  # 字符串e在索引1~5范围内出现的次数
1
 
# 2.center,ljust,rjust,zfill  （填充）
name='tony'
print(name.center(30,'-'))  # 总宽度为30，字符串居中显示，不够用-填充，不均衡右多左少
-------------tony-------------
print(name.ljust(30,'*'))  # 总宽度为30，字符串左对齐显示，不够用*填充
tony**************************
print(name.rjust(30,'*'))  # 总宽度为30，字符串右对齐显示，不够用*填充
**************************tony
print(name.zfill(50))  # 总宽度为50，字符串右对齐显示，不够用0填充
0000000000000000000000000000000000000000000000tony
 
# 3.expandtabs  （制表符）
name = 'tony\thello'  # \t表示制表符(tab键)
print(name)
tony    hello
print(name.expandtabs(1))  # 修改\t制表符代表的空格数
tony hello
 
# 4.captalize,swapcase,title
# 4.1 captalize：首字母大写
message = 'hello everyone nice to meet you!'
print(message.capitalize())
Hello everyone nice to meet you!  
# 4.2 swapcase：大小写翻转
message1 = 'Hi girl, I want make friends with you!'
print(message1.swapcase())  
hI GIRL, i WANT MAKE FRIENDS WITH YOU!  
#4.3 title：每个单词的首字母大写
msg = 'dear my friend i miss you very much'
print(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() #用于判断字符串是否是有效的 Python 标识符,可用来判断变量名是否合法。
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
print(dic.keys())  
dict_keys(['name', 'age', 'hobbies'])
# 获取字典所有的value
print(dic.values())
dict_values(['xxx', 18, ['play game', 'basketball']])
# 获取字典所有的键值对
print(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)           # 输出: 移除后的集合

数据类型总结

按存值个数区分
只能存一个值：可称为标量/原子类型	数字类型、字符串、布尔
可以存放多个值：可称为容器类型	列表、元祖、字典、集合

按照访问方式区分
直接访问：只能通过变量名访问整个值	数字类型
顺序访问：可以通过索引访问指定的值，索引代表顺序，又称为序列类型	字符串、列表、元祖
key访问：可以用key访问指定的值，又称为映射类型	字典

按可变不可变区分
可变类型	列表、字典
不可变类型	数字、字符串、元祖、布尔、集合

posted @ 2023-12-03 16:56 Xiao0101 阅读(21) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· python基础之数据类型

· MySQL之基本数据类型

· 数据类型的内置方法

· 各个数据类型的内置方法（字符串和列表）

· 各个数据类型的内置方法

阅读排行：
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
· C#/.NET/.NET Core优秀项目和框架2025年2月简报
· 葡萄城 AI 搜索升级：DeepSeek 加持，客户体验更智能
· 什么是nginx的强缓存和协商缓存
· 一文读懂知识蒸馏

公告

一个不像技术博客的博客

-------------------------------

时钟canvas

昵称： Xiao0101
园龄： 1年3个月
粉丝： 6
关注： 9

+加关注

2025年3月

日

一

二

三

四

五

六

随笔分类

随笔档案

阅读排行榜

评论排行榜

1. 爬虫之requests模块请求方式(1)

	# 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)
	print(res,type(res))
	(12.3, <class 'float'>)

	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

	- 浮点类型的内置方法包括各种数学运算，例如加法、减法、乘法和除法。
	- 此外，还有一些与浮点数相关的函数，如取整函数 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 = 'Ⅳ' # 罗马数字

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

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

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

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

	# 定义：在单引号\双引号\三引号内包含一串字符
	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 正向取(从左往右)
	print(str1[6])
	p
	# 1.2 反向取(负号表示从右往左)
	print(str1[-4])
	h
	# 1.3 对于str来说，只能按照索引取值，不能改值
	print(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 获取字符串的长度，即字符的个数，但凡存在于引号内的都算作字符)
	print(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! '
	print(str1.strip())
	life is short!

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

	# 6.切分split
	# 6.1 括号内不指定字符，默认以空格作为切分符号
	str3='hello world'
	print(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')
	print(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)
	print(str4)
	'my name is tonytonytony, my age is tony!'
	format的其他使用方式（了解）

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

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

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

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

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

	6.join
	# 从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串
	print('%'.join('hello')) # 从字符串'hello'中取出多个字符串，然后按照%作为分隔符号进行拼接
	'h%e%l%l%o'
	print('\|'.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('旧内容', '新内容')
	print(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'
	print(str8.isdigit())
	True

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

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

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

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

	# 4.captalize,swapcase,title
	# 4.1 captalize：首字母大写
	message = 'hello everyone nice to meet you!'
	print(message.capitalize())
	Hello everyone nice to meet you!
	# 4.2 swapcase：大小写翻转
	message1 = 'Hi girl, I want make friends with you!'
	print(message1.swapcase())
	hI GIRL, i WANT MAKE FRIENDS WITH YOU!
	#4.3 title：每个单词的首字母大写
	msg = 'dear my friend i miss you very much'
	print(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() #用于判断字符串是否是有效的 Python 标识符,可用来判断变量名是否合法。
	True
	>>> name.islower() # 字符串是否是纯小写
	True
	>>> name.isupper() # 字符串是否是纯大写
	False
	>>> name.isspace() # 字符串是否全是空格
	False
	>>> name.istitle() # 字符串中的单词首字母是否都是大写
	False

	# 定义：在[]内,用逗号分隔开多个任意数据类型的值
	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]

	# 在()内用逗号分隔开多个任意类型的值
	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循环一样遍历出数据类型中包含的每一个元素然后放到元组中

xiao

python中级之数据类型内置方法

引子

数字类型（int与float）

定义

类型转换

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

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

补充：判断数字类型

数字类型说明

1. 判断数字类型(isdigit)

2.判断小数类型(isdecimal)

3.判断数字类型(isnumeric)

4.无法判断浮点数

字符串类型（str）

定义

类型转换

内置方法（优先掌握）

内置方法（需要掌握）

内置方法（了解操作）

列表类型 （list）

定义

类型转换

内置方法（优先掌握）

内置方法（了解操作）

元组类型 （tuple）

定义

类型转换

内置方法

字典类型 （dict）

定义

类型转换

内置方法（优先掌握）

内置方法（需要掌握）

集合

定义

类型转换

内置方法

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

2. 去重

3. 其他操作

数据类型总结

公告

搜索

常用链接

合集

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

目录

列表类型（list）

元组类型（tuple）

字典类型（dict）

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

	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

	# 定义：在{}内用逗号分隔开多元素，每一个元素都是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
	print(dic.keys())
	dict_keys(['name', 'age', 'hobbies'])
	# 获取字典所有的value
	print(dic.values())
	dict_values(['xxx', 18, ['play game', 'basketball']])
	# 获取字典所有的键值对
	print(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}

	"""
	定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：
	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'}

	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

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