列表

1.定义：在[]内，用逗号分隔开多个任意数据类型的值

l1=[1,'a',[1,2]]  #本质：l1=list([1,'a',[1,2]])

2.类型转换

但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中

包含的每一个元素然后放到列表中

res=list('wdad')

print(res)    #['w', 'd', 'a', 'd']

res1=list([1,2,3])

print(res1)  #[1, 2, 3]

res2=list({'name':'jason','age':18})

print(res2)  #['name', 'age']  key值

res3=list((1,2,3))

print(res3)    #[1, 2, 3]

res4=list({1,2,3,4})

print(res4)  #[1, 2, 3, 4]

3.优先掌握的操作

1.1 按索引存取值(正，反向取)：可存可取,不可以根据索引添加值（当索引不存在时会直接报错）

my_friends=['tony','jack','jason',4,5]

print(my_friends[0])  #tony

1.2 反向取（负号表示从右往左）

print(my_friends[-1])    #5

1.3对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错

字典则是当key值不存在时会直接添加新的key:value键值对

my_friends[1]='martthow'

print(my_friends)

2.切片（顾头不顾尾，步长）

2.1 顾头不顾尾：去除索引为0到4的元素

print(my_friends[0:4])  #['tony', 'martthow', 'jason', 4]

2.2 步长：0:4:2，第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会去除索引0,2的值

print(my_friends[0:4:2])  #['tony', 'jason']

3.长度

print(len(my_friends))  #5

4.成员运算in和not in

print('tony'in my_friends)  #True

print('xxx' 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()（相当于for循环）一次性在列表尾部添加多个元素  也可以添加字符串,当里面（）是字典时会将字典的所有key值添加进去

l1.extend(['a','b','c'])

print(l1)  #['a', 'b', 'c', 'd', 'a', 'b', 'c']

l1.extend({'p':1,'o':2})

print(l1)

5.3 insert（）在指定位置插入元素  括号内索引值就是‘y'的索引值

l1.insert(2,'y')

print(l1)    #['a', 'b', 'y', 'c']

6.删除

6.1 del  根据索引指定删除列表内的元素，且不可恢复 无返回值（不能调用print功能）

l=[11,22,33,44]

del l[1]

print(l)  #[11, 33, 44]

6.2 pop() 默认删除列表最后一个元素，并将删除的值返回(代表的是取走操作)，括号内可以通过索引来指定删除的元素。

print(l.pop(2))  #print打印出来就是pop的返回值33

print(l)          #[11, 22, 44]

res=l.pop(2)      #res是将pop删除的值接收

print(res)          # 33

6.3 remove()括号内指明道姓表示要删除那个元素，没有返回值

print(l.remove(33))  #打印出来是None  因为remove没有返回值

res=l.remove(33)

print(res)          #None

print(l)            #[11, 22, 44]

6.4 clear() 作用是清空列表

6.5 count（）统计列表内元素的个数

7.reverse() 颠倒列表内的元素

print(l.reverse())    #返回值是None

print(l)                #[44, 33, 22, 11]

8.sort()给列表内所有的元素排序

8.1 排序时列表内元素之间必须是相同的数据类型，不可混搭，否则报错

l=[11,22,44,666,4,78,9,3]

print(l.sort())  #没有返回值 打印出来是None

l.sort()

print(l)  #[3, 4, 9, 11, 22, 44, 78, 666]  默认是从小到大排序

l.sort(reverse=True)  #reverse用来指定是否颠倒排序，默认为False

print(l)    #[666, 78, 44, 22, 11, 9, 4, 3]

8.2了解知识

列表，字符串也可以比较大小排序，都是依次比较大小根据的是它们在ASCII表中的先后顺序，越往后越大

l=['A','z','adjk','hello','hea']

l.sort()

print(l)      #['A', 'adjk', 'hea', 'hello', 'z']

9.循环

循环遍历列表里的值 可以将列表内的值一个一个打印出来  如果想要 打印出来的值在一行内 可以再后面加上end=''

for line in l:

    print(line,end='  ')    #A  adjk  hea  hello  z

4.3.2 了解操作

l=[1,2,3,4,5,6]

print(l[0:3:1])  #[1, 2, 3]  正向步长

print(l[2::-1])  #[3, 2, 1]  反向步长

通过索引取值实现列表翻转

print(l[::-1])  #[6, 5, 4, 3, 2, 1]

浅拷贝

就是当列表里包含可变类型时，新复制的列表里所存在的都是旧列表里的内存地址，当旧列表里可变类型内

的值发生该变时，可变类型的内存地址并不会发生改变，只是其内元素的内存地址发生了改变。所以当你打印

新列表时，新列表内的可变类型中的数据也会跟着改变。

l=[666,4,[78,9,3]]

l1=l[:]

print(id(l[2][0]))          #140710624829504

print(id(l[2][1]))          #140710624827296

print(id(l[2][2]))          #140710624827104

l[2][0]=8888

print(id(l[2][0]))          #2165566101936              #[666, 4, [8888, 9, 3]]    小列表里面的值都跟着改变了

print(id(l1[2][0]))        #2165566101936              #[666, 4, [8888, 9, 3]]  小列表里面的值都跟着改变了

l[0]=999

print(l)            #[999, 4, [78, 9, 3]]  复制

print(l1)          #[666, 4, [78, 9, 3]]

深拷贝：直接将被拷贝对象内所有的内存地址都拷贝到了新的对象里，不管其内套了多少层可变类型。

from copy import deepcopy

l3=deepcopy(l)

l[2][0]=8888

print(l3)        #[666, 4, [78, 9, 3]]

l=[666,333,4,[78,9,3],333,333,333]

l.insert(0,l)

l=[l,666,4,[78,9,3]]

print(l)

print(l[0])

print(l[0][0])

print(l[0][0][0][0][0][0][0][0])

print(len(l))

                                           元组

1.作用：元组与列表类似，也可以存多个任意类型的值，不同之处在于元组的元素不能修改，

即元组相当于一个不可变列表，用于记录多个固定不允许修改的值，单纯的用于取

2.定义方式：在（）内用逗号分隔开多个任意类型的值

countries=('中国','美国','英国')  #本质是：countries=tuple('中国','美国'，'英国')

强调：如果只有一个值，则必须在其后加上逗号，否则括号就只是包含的意思而非定义元组

countries=('中国',)  #本质是：countries=tuple('中国')

3.类型转换 ：但凡能被for循环遍历的任意数据类型都可以被转换成元组类型

print(tuple('wdad'))    #('w', 'd', 'a', 'd')

print(tuple([1,2,3]))  #(1, 2, 3)

print(tuple({'name':'egon','age':18}))    #('name', 'age')

print(tuple((1,2,3)))        #(1, 2, 3)

print(tuple({1,2,3,4}))        #(1, 2, 3, 4)

tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中

4.使用

4.1 按索引取值(正向取值加反向取) ：只能取不能改

tuple=(1,'hahaha',[11,22,33])

print(tuple[1])

print(tuple[-2])

tuple[0]='shdja'  #  TypeError

tuple[2][0]=11111

tuple[1]=11111    #报错

print(tuple)      #(1, 'hahaha', [11111, 22, 33])

4.2 切片

print(tuple[0:6:2])            #(1, 16000.0, 22)

4.3 长度len

print(len(tuple))

4.4 成员运算in 和not in

print('hahaha' in tuple )      #True

print('sdjhfjsd' in tuple)      #False

5.循环

for line in tuple:

    print(line,end='  ')    #1  hahaha  16000.0  11  22  33

                                         字典

1.定义：在{}内用逗号分隔开多个元素，每一个元素都是key:value的形式，其中value=可以是任意类型

而key必须是不可变类型，通常是字符串类型

info={'name':'tony','age':18,'sex':'male'}    #本质info=dict（{...}）

也可以这样定义字典

info=dict(name='tony',age=18,sex='male')  #info={'name': 'tony', 'age': 18, 'sex': 'male'}

print(info)

2.类型转换：

2.1：

info=dict([['name','tony'],('age',18)])

print(info)  #{'name': 'tony', 'age': 18}

2.2:formakeys会将包含多个元素的数据类型for循环出来（元组/列表/集合/字典）,取出每个值当做key，然后与None组成key：value放到字典中

print({}.fromkeys(('name','age','sex'),None))        #{'name': None, 'age': None, 'sex': None}

print({}.fromkeys(['name','age','sex'],None))        #{'name': None, 'age': None, 'sex': None}

print({}.fromkeys({'name','age','sex'},None))        #{'age': None, 'name': None, 'sex': None}

print({}.fromkeys({'name':'egon','age':18,'sex':'male'},None)) #{'name': None, 'age': None, 'sex': None}

传入的是字典会将字典的key值当做新字典的key值，value值改为None

print({}.fromkeys(('name','age','sex'),56565))        #print({}.fromkeys(('name','age','sex'),56565))

3使用方法

3.1优先掌握的操作

3.1.1 按key取值，可存可取

dic={'name':'jfdhh','age':18,'hobbies':['play game','basketball']}

print(dic['name'])        #jfdhh

print(dic['hobbies'][1])  #basketball

print(dic['sadas'])      #  key  值不存在则会报错

3.1.2 对于赋值操作，如果key不存在于字典中，则会新增key:value

dic['gender']='male'

print(dic)    #{'name': 'jfdhh', 'age': 18, 'hobbies': ['play game', 'basketball'], 'gender': 'male'}

3.1.3 对于赋值操作，如果key原先存在于字典，则会修改对应的value值

dic['name']='qiqi'

print(dic)    #{'name': 'qiqi', 'age': 18, 'hobbies': ['play game', 'basketball'], 'gender': 'male'}

3.2长度len

print(len(dic))  #4

3.3成员运算in和not in  判断某个值是否存在于字典的key值

print('name' in dic)    #True

3.4 删除

 del  万能删除　　ｄｅｌ　字典名［’ｋｅｙ’］

3.4.1  pop 指定字典的key来删除字典的键值对

print(dic.pop('name'))    #qiqi

print(dic)                #{'age': 18, 'hobbies': ['play game', 'basketball'], 'gender': 'male'}

3.4.2 popitem() 随机删除一组键值对并将删除的键值对放回在一个元组内

print(dic.popitem())      #('gender', 'male')

del dic['name']

print(dic)                    #{'age': 18, 'hobbies': ['play game', 'basketball'], 'gender': 'male'}

print(dic.clear())            #清空字典 返回None

5 键keys(),值values（），键值对items（）

dic={'name':'jfdhh','age':18,'hobbies':['play game','basketball']}

获取字典所有的key　　　与ｆｏｒ　循环取值一样

print(dic.keys())        #dict_keys(['name', 'age', 'hobbies'])

获取字典所有的value值

print(dic.values())    #dict_values(['jfdhh', 18, ['play game', 'basketball']])

获取字典所有的键值对        返回值列表套元组

print(dic.items())      #dict_items([('name', 'jfdhh'), ('age', 18), ('hobbies', ['play game', 'basketball'])])

6.循环

6.1 默认遍历的是字典的key

for key in dic:

    print(key,end='  ')    #name  age  hobbies

6.2 只遍历key

for key in dic.keys():

    print(key,end='  ')    #name  age  hobbies

6.3只遍历value

for key in dic.values():

    print(key,end='  ')    #jfdhh  18  ['play game', 'basketball']

6.4遍历key与value    以元组的形式返回

for key in dic.items():

    print(key,end='  ')    #('name', 'jfdhh')  ('age', 18)  ('hobbies', ['play game', 'basketball'])

7 get（） 取值操作    一般建议用get取值

dic= {'k1':'jason','k2':'Tony','k3':'JY'}

print(dic.get('k1'))        #jason      key存在则获取key对应的value值

print(dic.get('k12'))      #None        key不存在，不会报错，而是会默认返回None

print(dic.get('xxx',666))  #666        key不存在时，可以设置默认的返回值

8.update 用新字典更新旧字典，有则修改，无则添加

dic= {'k1':'jason','k2':'Tony','k3':'JY'}

print(dic.update({'k1':'JN','k4':'xxx'}))        #返回值返回的是None

print(dic)                                      #{'k1': 'JN', 'k2': 'Tony', 'k3': 'JY', 'k4': 'xxx'}

9.setdefault()  key不存在则新增键值对，并将新增的value返回

print(dic.setdefault('k4',444))    #444

print(dic)                          #{'k1': 'jason', 'k2': 'Tony', 'k3': 'JY', 'k4': 444}

key存在则不做任何修改，变且返回已存在key对应的value值

print(dic.setdefault('k2',9999))  #Tony

print(dic)                          #{'k1': 'jason', 'k2': 'Tony', 'k3': 'JY'}