数据类型的内置方法

数据类型的内置方法

列表的内置方法

1.类型转换

能够被for循环的数据类型都能够类型转换成列表，整型和浮点型及布尔型都不能，因为整型和浮点型是一个数，不是集合，是不可迭代对象。

2.索引

利用索引可对列表进行数据的查询，可查询一个数据也可以查询多个数据。

变量名或列表[索引值]，索引值是从0开始表示列表中第一个数据的位置，索引值减1是表示列表最后一个数据的位置。索引取值是从左往右取值的，正数表示是正向取值，就是从头开始取，负数表示反向取值，如-1表示倒数第一个数据值的索引，负数的索引不需要减一，但是顺序还是从左往右取值。

l1 = ['apple', 'orange', 22, 66]
print(l1[1])    # orange
print(l1[-0])   # apple
print(l1[-1])   # 66

3.切片

变量名或列表[起始索引值, 末端索引值]，中括号内有两个数值，第一个数值表示开始的索引位置，第二个数值表示末端的索引值，可取出这两者索引之间的数据值，叫切片。切片生成的是列表。若有值为负数表示方向，顺序是从左往右切片。

l1 = ['apple', 'orange', 22, 66]
print(l1[1:2])      # ['orange']
print(l1[1:-1])     # ['orange', 22]
print(l1[-3:-1])    # ['orange', 22]
print(l1[-1:-3])    # []

4.间隔

变量名或列表[起始索引值:末端索引值:间隔数]，中括号内有三个数值，第一个数值表示开始的索引位置，第二个数值表示末端的索引值，第三个数表示间隔数，可看成等差数列，首项，末项，公差。若有负值表示方向，（间隔数不需要为负数，它并不表示方向）。

l1 = ['apple', 'orange', 22, 66, 88]
print(l1[1:4:2])        # ['orange', 66]
print(l1[-4:-1:2])      # ['orange', 66]
print(l1[-1:-4:2])      # []

5.统计列表内数据值的个数

统计的字符串内数据值的个数，也就是逗号隔开的数据值。

l1 = ['apple', 'orange', 22, 66, 88]
print(len(l1))  # 5

6.增加列表中的数据值

方式1：关键字 append ，增加列表的数据值，但是只能从尾部增加。并且只能在列表中查看，不能单独查看增加的值。

l1 = ['apple', 'orange', 'banana', 'lemon']
res = l1.append('grape')
print(res)  # None
print(l1)   # ['apple', 'orange', 'banana', 'lemon', 'grape']

方式2：关键字 insert(,) ，insert后面的括号内有两个值，第一个是索引值，第二个是要插入的数据值。可以在指定的位置插入数据值。第二位置的数据值可以是任意类型，但是无论写多少个数据值插入的都是整体。

l1 = ['apple', 'orange', 'banana', 'lemon']
l1.insert(2, 'grape')
print(l1)   # ['apple', 'orange', 'grape', 'banana', 'lemon']
l1.insert(3, (1, 2, 3))
print(l1)   # ['apple', 'orange', 'grape', (1, 2, 3), 'banana', 'lemon']

方式3：关键字 extend() ，扩展列表，可使用for循环添加，也可使用 + 使两个列表的值整合在一起。但是推荐使用的是extend，必须要for可以循环的数据类型才可以使用。

# 使用for循环可实现两个列表之间的扩展
l1 = ['apple', 'orange']
l2 = ['banana', 'lemon']
for i in l1:    # 循换l1中的每个数据值
    l2.append(i)    # l2末尾依次增加l1中的数据值
print(l2)   # 循环结束打印结果

# 使用 + 算术运算符，可以使两个列表之间的数据值整合到一个列表中，相当于字符串的拼接。
l1 = ['apple', 'orange']
l2 = ['banana', 'lemon']
print(l1 + l2)      # ['apple', 'orange', 'banana', 'lemon']

'''使用关键字extend，可将两个列表的数据值整合到一个列表，但是extend括号里面的数据类型只能是支持for循环的数据类型'''
l1 = ['apple', 'orange']
l2 = ['banana', 'lemon']
l1.extend(l2)
print(l1)   # ['apple', 'orange', 'banana', 'lemon']

7.删除列表中的数据值

方式1：关键字 del ，使用del加列表的索引删除指定的数据值。

l1 = ['apple', 'orange', 'banana', 'lemon', 'grape']
del l1[4]
print(l1)     # ['apple', 'orange', 'banana', 'lemon']

方式2：关键字 remove()，使用remove()括号里是想要删除的数据值，直接删除。

l1 = ['apple', 'orange', 'banana', 'lemon', 'grape']
l1.remove('grape')
print(l1)   # ['apple', 'orange', 'banana', 'lemon']

方式3：关键字 pop()，使用pop()括号里是想要删除数据值对应的索引值，默认情况下即不填就是删除末尾的数据值。

l1 = ['apple', 'orange', 'banana', 'lemon', 'grape']
l1.pop()
print(l1)   # ['apple', 'orange', 'banana', 'lemon']
l2 = ['apple', 'orange', 'banana', 'lemon', 'grape']
l2.pop(3)
print(l2)   # ['apple', 'orange', 'banana', 'grape']

8.修改列表中的数据值

使用列表索引绑定一个新的数据值进行修改。

l1 = ['apple', 'orange', 'banana', 'lemon']
l1[3] = 'grape'
print(l1)   # ['apple', 'orange', 'banana', 'grape']

9.查找列表中的数据值

通过列表的索引、切片、间隔都可以查找列表中的数据值。

l1 = ['apple', 'orange', 22, 66]
print(l1[1])    # orange
print(l1[1:-1])     # ['orange', 22]
print(l1[-4:-1:2])      # ['orange', 66]

10.统计列表中相同数据值出现的次数

使用count()，括号内可以填入想要统计的数据值。

l1 = ['orange', 'apple', 'orange', 'banana', 'orange', 'lemon', 'grape', 'orange']
count = l1.count('orange')
print(count)    # 4
print(l1.count('orange'))   # 4

11.排序

对列表中的数据值进行按照一定的规律排序，如果想要从小到大排使用升序，反之使用降序。但是升序和降序使用的是同一个关键字。在关键字 sort() 括号内写上 reverse=True 表示降序，不写默认升序。

l1 = [22, 11, 88, 66, 44, 55, 99, 33, 77]
l1.sort()
print(l1)   # [11, 22, 33, 44, 55, 66, 77, 88, 99]
print(l1.sort())    # None
l1.sort(reverse=True)
print(l1)   # [99, 88, 77, 66, 55, 44, 33, 22, 11

12.翻转

将列表中的的数据值从右到左翻转。

l1 = [22, 11, 88, 66, 44, 55, 99, 33, 77]
l1.reverse()
print(l1)   # [77, 33, 99, 55, 44, 66, 88, 11, 22]

13.比较运算

比较的是两个列表中的一一对应的数据值的大小。中文、字母都可进行编码转换成数字进行比较。一一对应比较。比较第一个出结果后后面便不比较了。

l1 = [13, 21, 33]
l2 = [28, 11, 16, 17]
print(l1 > l2)  # False
print(l2 > l1)  # True
l11 = [13, 21, 33]
l22 = [13, 11, 16, 17]
print(l11 > l22)  # True
l3 = ['a', 5]
l4 = ['A', 10, 7]
print(l3 > l4)  # True
l5 = ['你', 22]
l6 = ['我', 11, 33]
print(l5 > l6)  # False

可变类型和不可变类型

1.可变类型

可变类型是指，数据值改变内存地址可以不变的数据类型。如list、dict

2.不可变类型

不可变类型是指，数据值改变内存地址便的数据类型。如int、str、float

'''元组内的元素只能查看不能修改，指的是元组内索引指向的内存地址不能被修改'''
s1 = ('apple', 'orange', 'banana', ['lemon', 'grape'])
s1[2] = 'banana'
print(s1) # 报错
s1[3][1] = 'banana'
print(s1)   # ('apple', 'orange', 'banana', ['lemon', 'banana'])
'''若元组内存在可变的数据类型，那么这个可变的数据类型中的值是可以修改的，但是修改后的内存地址是不变的。'''

元组的内置方法

1.类型转换

只有支持for循环的数据类型才能够被转成元组。

print(tuple(222))   # 报错
print(tuple(22.2))  # 报错
print(tuple('orange'))  # ('o', 'r', 'a', 'n', 'g', 'e')
print(tuple([11, 22, 33]))  # (11, 22, 33)
print(tuple({'name': 'orange', 'age': 18})) # ('name', 'age')
print(tuple({123, 234, 345}))   # (345, 234, 123)

'''当元组内只有一个数据值时，逗号不能省略，哪怕只有一个数据值，不然元组内那一个数据值是什么数据类型就是什么数据类型'''
print(type(('orange'))) # <class 'str'>
print(type((123)))  # <class 'int'>

2.索引

可对元组内的数据进行查询。变量名或元组[索引值]，索引值是从0开始表示元组中第一个数据的位置，索引值减1是表示列表最后一个数据的位置。索引取值是从左往右取值的，正数表示是正向取值，就是从头开始取，负数表示反向取值，负数的索引不需要减一，但是顺序还是从左往右取值。

t1 = (11, 22, 33, 44, 55)
print(t1[2])    # 33
print(t1[-2])   # 44

3.切片

变量名或元组[起始索引值, 末端索引值]，中括号内有两个数值，第一个数值表示开始的索引位置，第二个数值表示末端的索引值，可取出这两者索引之间的数据值，叫切片。切片生成的是元组。若有值为负数表示方向，顺序是从左往右切片。

t1 = (11, 22, 33, 44, 55)
print(t1[1:3])      # (22, 33)
print(t1[-3:-1])    # (33, 44)
print(t1[-1:3])     # ()
print(t1[:])        # (11, 22, 33, 44, 55)

4.间隔

变量名或元组[起始索引值:末端索引值:间隔数]，中括号内有三个数值，第一个数值表示开始的索引位置，第二个数值表示末端的索引值，第三个数表示间隔数，可看成等差数列，首项，末项，公差。若有负值表示方向，（间隔数不需要为负数，它并不表示方向）。

t1 = (11, 22, 33, 44, 55, 66, 77)
print(t1[1:4:2])        # (22, 44)
print(t1[1:-1:2])       # (22, 44, 66)
print(t1[-6:-3:2])      # (22, 44)
print(t1[-6:-3:-2])     # ()
print(t1[-1:-6:2])      # ()

5.查询元组内的数据值

元组的查询和索引查找是一个道理，但是元组只能存储数据不能修改数据即只能查找不能修改。

print(t1[6])    # 77
t1[6] = 222
print(t1)       # 报错

字典的内置方法

1.类型转换

由于字典的是K:V键值对的形式，所以不常进行类型转换。

print(dict([('name', 'orange'), ('pwd', 123)])) # {'name': 'orange', 'pwd': 123}
print(dict(name='apple', pwd=321))  # {'name': 'apple', 'pwd': 321}

2.不能索引

由于字典内的数据值都是无序的，所以不能使用索引取值。

3.取值操作

方式1：对于字典的取值操作都是通过获取K值进行查看，但是要注意的是若K不存在会报错。

方式2：获取字典中的K值，通过变量名或字典.get()，括号内是对于的K值，若K值不存在会输出None，程序不会报错。

d1 = {'name': 'apple', 'pwd': 321, 'hobby': 'read'}
print(d1['name'])   # apple
print(d1['age'])    # 报错
print(d1.get('name'))   # apple
print(d1.get('age'))    # None

4.统计字典中键值对的个数

使用变量名或字典.len()，可查看字典中多多少键值对。

5.修改字典内的数据值

直接利用K值绑定一个新的数据值进行数据值修改字典内的数据值。

d1 = {'name': 'apple', 'pwd': 321, 'hobby': 'read'}
d1['name'] = 'orange'
print(d1)  # {'name': 'orange', 'pwd': 321, 'hobby': 'read'}

6.增加字典内的数据值

利用K值绑定一个新的数据值，但是这个K值是不存在的，这就可以增加字典内的数据值。

print(dict([('name', 'orange'), ('pwd', 123)])) # {'name': 'orange', 'pwd': 123}
print(dict(name='apple', pwd=321))  # {'name': 'apple', 'pwd': 321}

7.删除字典内的数据值

方式1：del 变量名或字典[K值]，通过删除K值对整个K:V键值对进行删除。

d1 = {'name': 'apple', 'pwd': 321, 'hobby': 'read'}
del d1['hobby']
print(d1)   # {'name': 'apple', 'pwd': 321}

方式2：变量名或字典.pop(K值)，通过删除K值对整个K:V键值对进行删除。

d1 = {'name': 'apple', 'pwd': 321, 'hobby': 'read'}
res = d1.pop('pwd')
print(d1)   # {'name': 'apple', 'hobby': 'read'}
print(res)  # 321

方式3：变量名或字典.popitem()，因为字典本身就是无序的，可随机删除任意一个数据值，但是删除一个后再执行便不会再删除了，这是优化。

d1 = {'name': 'apple', 'pwd': 321, 'hobby': 'read'}
d1.popitem()
print(d1)  # {'name': 'apple', 'pwd': 321}

8.快速获取键值对的数据

变量名或字典.keys()，是获取字典中所有的K值，结果是列表

变量名或字典.values()，是获取字典所有的V值，结果是列表

变量名或字典.items()，获取的是K:V键值对，结果是列表，K:V之间用()

d1 = {'name': 'apple', 'pwd': 321, 'hobby': 'read'}
print(d1.keys())    # dict_keys(['name', 'pwd', 'hobby'])
print(d1.values())  # dict_values(['apple', 321, 'read'])
print(d1.items())   # dict_items([('name', 'apple'), ('pwd', 321), ('hobby', 'read')])

9.修改字典

变量名或字典.update()，可利用K值更新V值，若键不存在就是新增。

d1 = {'name': 'apple', 'pwd': 321, 'hobby': 'read'}
d1.update({'name': 'orange'})
print(d1)   # {'name': 'orange', 'pwd': 321, 'hobby': 'read'}
d1.update({'age': 123})
print(d1)   # {'name': 'orange', 'pwd': 321, 'hobby': 'read', 'age': 123}

10.快速构造字典

变量名或字典.fromkeys()，可快速构造一个字典但是V值是为None，若想添加V值，需要在K值的末尾添加数据。

d1 = dict.fromkeys(['name', 'pwd', 'hobby'], )
d2 = dict.fromkeys(['name', 'pwd', 'hobby'], [])
print(d1)  # {'name': None, 'pwd': None, 'hobby': None}
print(d2)  # {'name': [], 'pwd': [], 'hobby': []}
d2['name'].append('orange')
print(d2)

集合的内置方法

1.类型转换

只有能够被for循环的数据类型才能够转换成集合。

定义空集合只能用关键字set()，不然程序会默认定义的是字典。

集合内的数据必须是不可变的类型，如整型、浮点型、布尔型

元组、字符串。

2.去重

取出集合内重复的数据值

s1 = {1, 2, 3, 4, 5, 2, 4, 5, 1, 2, 6}
print(s1)   # {1, 2, 3, 4, 5, 6}

3.关系运算

&		共同的部分
-		独有的部分
|		全部的部分(和)
^		独有部分的和

s1 = {'apple', 'orange', 'banana', 'fruit'}
s2 = {'lemon', 'grape', 'apple', 'orange'}
print(s1 & s2)  # {'orange', 'apple'}
print(s1 - s2)  # {'fruit', 'banana'}
print(s2 - s1)  # {'lemon', 'grape'}
print(s1 | s2)  # {'fruit', 'apple', 'lemon', 'orange', 'banana', 'grape'}
print(s1 ^ s2)  # {'fruit', 'lemon', 'grape', 'banana'}

作业

1.利用列表编写一个员工姓名管理系统
	输入1执行添加用户名功能
	输入2执行查看所有用户名功能
 	输入3执行删除指定用户名功能
	ps:思考如何让程序循环起来并且可以根据不同指令执行不同操作
	提示: 循环结构 + 分支结构
	拔高: 是否可以换成字典或者数据的嵌套使用完成更加完善的员工管理而不是简简单单的一个用户名(能写就写 不会没有关系)
# 1.先提示用户功能
# 2.让用户输入想要执行的功能编号
# 3.如果用户输入1表示执行功能1，若用户输入2表示执行功能2，若用户输入3表示执行功能3
# 4.添加while循环，使可以重复执行功能的输入和功能的执行
user = ['tom', 'lili', 'jenny', 'jack']  # 定义用户表，存放些数据，好看
print('输入1执行添加用户名功能')   # 打印输出功能表
print('输入2执行查看所有用户名功能')
print('输入3执行删除指定用户名功能')
while True:     # 条件一直成立，可一直循环
    function = input('请输入你要执行的功能数字：').strip()  # 输入想要执行功能的数字代码
    function = int(function)    # 输入的数字转换成整型
    if function == 1:   # 若输入的数值为1则执行
        f1 = input('请输入你要添加的姓名：').strip()   # 输入添加的姓名，并除去开头或结尾的空格
        add = user.append(f1)  # 添加用户名放在列表的末尾
        print(user)
    elif function == 2:  # 若输入的数值为2则执行
        print(user)     # 直接打印输出便可查看全部
    elif function == 3: # 若输入的数值为2则执行
        f3 = input('请输入你要删除的姓名：').strip()   # 输入删除的姓名，并除去开头或结尾的空格
        det = user.remove(f3)   # 删除指定的用户名
        print(user)

2.去重下列列表并保留数据值原来的顺序
	eg: [1,2,3,2,1] 去重之后 [1,2,3]
	l1 = [2,3,2,1,2,3,2,3,4,3,4,3,2,3,5,6,5]
# 1.循环列表中的值
# 2.如果列表中的值不在空集合里则添加该数据值
l1 = [2, 3, 2, 1, 2, 3, 2, 3, 4, 3, 4, 3, 2, 3, 5, 6, 5]
a = []
for i in l1:    # 循环列表
    if i not in a:   # 如果列表中的值不在空集合里，则将值添加到空列表中
        a.append(i)  # 那么已存在之后就不会添加到定义的空列表中
print(a)

3.有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
　　pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
　　linuxs={'kermit','tony','gangdan'}
　　1. 求出即报名python又报名linux课程的学员名字集合
　　2. 求出所有报名的学生名字集合
　　3. 求出只报名python课程的学员名字
　　4. 求出没有同时这两门课程的学员名字集合
pythons = {'jason', 'oscar', 'kevin', 'ricky', 'gangdan', 'biubiu'}
linuxs = {'kermit', 'tony', 'gangdan'}
print(pythons & linuxs)
print(pythons | linuxs)
print(pythons - (pythons & linuxs))  # 报python的人减去两门课都报名的人
print(pythons ^ linuxs)