列表元素可以被修改,” 空字符为假

列表元素可以被修改,  逗号分隔每个元素,” 空字符为假,最少使用的位数,data = v.bit,list.xx()就是对象的方法,一、列表功能及方法

图片 122
1、循环字典中所有的key
    for item in info.keys():
        print(item)


2、循环字典中的所有values(值)
    for item in info.values():
    prent(item)            


3、既要循环key又要循环字典中所有的值
     for item in info.keys():
        print(item,info[item])

     那么可以简写为:
    for k, v in info.items():
        print( k, v )

《》《》《》《》字典的方法《》《》《》《《》》
1、clear 清空

2、copy 浅拷贝

3、fromkeys  根据序列创建字典,并且制定统一的值
    用法: v= dict.fromkeys(['k1', 123, 'k2'], 22)

4、通过索引取key,如果字典中没有会直接报错
    get  用法:查找字典的key,key不存在时可以指定默认值

    方法一:
            dic = {"k1":23, "k2": 24}
            v= dic.get("k3")
            print(v)       如果k3不在字典中,则返回None
    方法二:
            dic = {"k1":23, "k2": 24}
            v= dic.get("k3",1111)
            print(v)       如果k3不在字典中,则返回1111      
5、items

6、 keys

7、 pop     删除。既可以指定所要删除的值,又可以拿到删除掉的值

        方法一:
        dic = {"k1":23, "k2": 24}
        v = dic.pop('k1') 
        print(dic,v)
       方法二:设定具体值,当要删除的key不存在时,返回到设置的值
         dic = {"k1":23, "k2": 24}
         v = dic.pop('k5',1111) 
         print(dic,v)   


8、  popitem随机删除,并返回删除的值

       dic = {"k1":23, "k2": 24}
        v,k = dic.popitem() 
        print(dic,v,k)   

9、setdefault设置值,如果值已经存在,并获取存在key对应的值
    如果key不存在,创建并获取新创建的key的值
   例如: dic = {"k1":23, "k2": 24}
             v = dic.setdefault("k111","alex") 
             print(dic,v)

10、update 更新

dic = {"k1":23, "k2": 24}
方法一:dic.update({'k1': 1111, 'k3',123})
            print(dic)
方法二: dic.update(k1=123, k3=345, k5='alex')
            print(dic)   

 

6.1.1 len()

 图片 1

11,切成片,切成块结果也是列表

  字典的value能够是其余值

num=9%2

11.2.11 for循环

 图片 2

1 li = [11, 22, 33, 22, 44]2  li.append(5)3  li.append("alex")4  li.append([1234,2323])5  print

  索引切成块修正: li [1:3] = [27, 28]

方法

3.1.14 format()

格式化字符串

(1)

 图片 3

(2)

 图片 4

(3)

 图片 5

(4)

 图片 6

[11, 33, 22, 44] 只删除第三个成分22
PS: pop暗中同意从最终多少个去除, remove暗许侧面优先, del
li[0]去除钦点索引地点的要素 del li[7:9]切开整段删除,
clear清空驶列车表。

3、for循环

 

5.2.6 嵌套

列表中的成分得以是:数字,字符串,布尔值,列表

li = [11,22,[6,“88991”,7],33,True,“蒋毅”,55]
val = li[2][1][-1]
print(val)

li[3] = 66
print(li)

li[2][2] = 77
print(li)

li[2][1] = 666
print(li)

li[5] = li[5].replace(‘蒋’,‘江’)
li[5] = “江毅” print(li)

 图片 7

2 清空驶列车表
li.clear()
print

  索引删除: del li [1]     print(li)

test=input('请输入:')
v=range(0,len(test))
for item in v:
    print(item,test[item])

6.1.2 索引

 图片 8

# info = {
# “k1”: 18,
# “k2”: True,
# “k3”: [
# 11,
# [],
# (),
# 22,
# 33,
# {
# ‘kk1’: ‘vv1’,
# ‘kk2’: ‘vv2’,
# ‘kk3’: ,
# }
# ],
# “k4”: (11,22,33,44)
# }
# print

=================list之灰法力================

 

7.2.4 删除

del

 图片 9

3 拷贝,浅拷贝
v = li.copy()
print

5、列表元素能够开展退换

             key    列表,字典,不可为key
;bool值  True  暗中认可=1   False  暗中同意=0,若是重复是  则不展现

5.1.5 index()

找参数的任务

 图片 10

# for k,v in info.items():
# print

  li=[‘alex’, ‘小名’, [12, 23, 45],
23, 23, ‘小花’]

图片 11

5.2.4 替换

 图片 12

44

    for i in li :

print(v)        True

3.1.22 isspace()

 图片 13

输出结果为:

  逗号分隔各样成分,

图片 14

5.2.3 循环

for

 图片 15

print

6、删除

test='12'
v=test.isdigit()         # 判断字符串是否只包含数字          
print(v)

11、集合(set类)

>>> li = [11, 22, 33, 22, 44]>>> li.append([77,99])>>> print[11, 22, 33, 22, 44, [77, 99]]

三、字典 dict

着力数据类型

3.1 字符串提供的效果

3.1.1 upper()

变大写

 图片 16

3.1.2 lower()

变小写

 图片 17

3.1.3 capitalize()

首字母变大写,其余变小写

 图片 18

3.1.4 strip()

删除首尾空格、换行、制表符、拟定的故事情节

 图片 19

示例:

 图片 20

3.1.5 lstrip()

删除左侧空格

 图片 21

3.1.6 rstrip()

除去左侧空格

 图片 22

3.1.7 replace()

替换

 图片 23

图片 24

 

 图片 25

图片 26

3.1.8 split()

分割

 图片 27

图片 28

图片 29

图片 30

3.1.9 isdecimal()

判断当前字符串中是否全都是数字

 图片 31

示例:

count = 0
v = “abc123fsdfa3f”
for
item in v:
    if item.isdecimal():
        count += 1
print(count)

 图片 32

 

它与append的歧异在于,append会把任何输入对象作为三个要素出席到列表的后面。

  索引改革: li [ 2 ] =120    print(li)

图片 33    程序报错

5.3 删除补充

删去列表成分时,会影响列表长度,从而使得索引取值时,轻便并发谬误。

 图片 34

缓和格局:

# 技术方案后生可畏: li = [11, 22, 33, 44, 66] # 0 new_list = []
# 索引为奇数值,删除
**
for i in range(0,len(li)):
    
if** i%2 == 0:
        new_list.append(li[i])
li = new_list
print(li)

 图片 35

# 实施方案二: li = [11, 22, 33, 44, 66] # 0
# 索引为奇数值,删除
#倒序删除rang(4,-1,-1)
**
for i in range(len(li)-1,-1,-1): # 4,0
    
if i%2 == 1:
        
del** li[i]
print(li)

 图片 36

# 技术方案三:
#切片+步长
li = [11, 22, 33, 44, 66]
#del li[0:4]
**
del** li[0:4:2]
print(li)

 图片 37

33

  列表中的成分得以是数字、字符串、列表、布尔值、等具有的都能放进去

count  : v = tu.count(33)    获取成分33 
在 tu中冒出的次数

4、int-bool-str转换

int    89  90

bool   True False

str  ‘sdf’ ‘7’

li = [1, 12, 9, "age", ["石振文", ["19", 10], "庞麦郎"], "alex", True]  # 通过list类创建的对象,li

2、删除key :   del info[“k1”]

test='syeijc435_+'
v=test.isalnum()        # 判断字符串中是否只包含字母和数字,若有其他符号 ,则结果为false
print(v)

3.1.13 find()、index()

find()

在字符串中找找,找不到重回-1

 图片 38

 

index()

在字符串中寻觅,找不到报错

 图片 39

li = [11, 22, 33, 22, 44]

7、支持 in 操作

结果为 false

8.第22中学间原理

在硬盘内部存款和储蓄以0101010花样积累,可是出口查看时以bytes格局显得

utf-8或gbk…

utf-8

    二个字符多个字节,内部用二进制表示

01100001      a

01101100       l

01100101      e

01111000      x

00000010 00000000 00000000 00000110 00000000 00000000  海娇

 

gbk

三个字符七个字节

00000000 01100001      a

00000000 01101100       l

00000000 01100101      e

00000000 01111000      x

 

10000010 00000000          海

10000010 00100000          娇

 

xxx

00000000 00000000 01100001     a

00000000 00000000 01101100     l

00000000 00000000 01100101     e

00000000 00000000 01111000     x

 图片 40

[11, 22, 33, 22, 44, 9898, ‘不得了’]

 二、元祖
tuple     

 

3.1.21 isalpha()

决断字符串的源委是或不是是纯字母

 图片 41

View Code

    li = [12,13,14,’xiaozhang’, ‘xiaowang’]

b=bool(a )’

11.2.10 update()

更新

 图片 42

# 5、索引方式找到内定成分
# info = {
# “k1”: 18,
# 2: True,
# “k3”: [
# 11,
# [],
# (),
# 22,
# 33,
# {
# ‘kk1’: ‘vv1’,
# ‘kk2’: ‘vv2’,
# ‘kk3’: ,
# }
# ],
# “k4”: (11,22,33,44)
# }
# # v = info[‘k1’]
# # print
# # v = info[2]
# # print
# v = info[‘k3’][5][‘kk3’][0]
# print

  索引切成块删除: del li [2,4]    print(li)

 

7.1.4 items()

 图片 43

# 2 依据Key获取值,key不设不常,能够钦命暗中认可值
# v = dic[‘k11111’]
# print
# v = dic.get(‘k1’,111111)
# print

  布尔值,列表、字典无法充任字典的key

拜望顺序:①:直接访谈:数字

6、元组(tuple类)

不可变的容器

独有一个因素时,一定加逗号(1,)

>>> li = [11, 22, 33, 22, 44]>>>>>> li.extend #如果输入的对象是不可迭代的,它会报错。Traceback (most recent call last):  File "<stdin>", line 1, in <module>TypeError: 'int' object is not iterable

4、支持for循环,   while循环。

1、字典是冬天的

bit_length()

当下十进制用二进制表示时,起码使用的位数

 

v = 15
# 当前十进制用二进制表示时,最少使用的位数 data = v.bit_length()
print(v)
print(data)

 图片 44

View Code

  假诺列表中即有数字又有字符串,需求和谐写二个for循环

图片 45

11.2.12 len()

长度

 图片 46

View Code

    print(s)

count=count+1  即  count+=1

5.2 公共职能

图片 47图片 48

v = info[key]    例如: v=info[“k1”]

 
 设置值,若key以存在,则不设置,获取当前k对应的值;
荒诞不经时,设置并获得当前K对应的值

11.2.4 dicard()

在汇聚中删去制订值

 图片 49

>>> li = [11, 22, 33, 22, 44]>>> li.insert  #指定在第一个位置插入99>>> print[99, 11, 22, 33, 22, 44]>>> li.insert  #指定在第三个位置插入99>>> print[99, 11, 99, 22, 33, 22, 44]

2、能够举行for循环(可迭代对象卡塔尔

 

5.1.9 copy()

复制、浅拷贝

 图片 50

有三个特征:浅copy,只copy第生机勃勃层

昨日的必要是要出口的names2与第一行names定义的均等

name1 = [“zhangyang”,“guyun”,“xiangpeng”,“xulang”]
name2 = name1.copy()
name1[1] = “古云” print(name1)
print(name2)

 图片 51

name1 =
[“zhangyang”,“guyun”,“xiangpeng”,[“jack”,“alex”],“xulang”]
name2 = name1.copy()
name1[1] = “古云” name1[3][0] = “杰克” print(name1)
print(name2)

 图片 52

列表的天性

 图片 53

与字符串或数字不相同

 图片 54

深拷贝

import copy
name1 =
[“zhangyang”,“guyun”,“xiangpeng”,[“jack”,“alex”],“xulang”]
name2 = copy.deepcopy(name1)
name1[1] = “古云” name1[3][0] = “杰克” print(name1)
print(name2)

 图片 55

简述深浅拷贝

#倘诺拷贝单层列表时,深浅拷贝都把原列表拷贝到了一个新的内部存储器地址,所以原列表被改变新列表都不会被改变

#假诺拷贝多层列表时

    #浅拷贝只将原列表的第意气风发层拷贝到了新的内部存款和储蓄器地址,新列表二层及以内的仍旧指向原列表的内存地址,所以原列表被更动,新列表的

    #先是层不会转移,二层及以内的会跟着新列表改进

    #深拷贝是将原列表的富有都拷贝到了新的内部存款和储蓄器地址,原列表被校勘,新列表不会改变

View Code

1、列表格式:

 

5.2.5 删除

del

 图片 56

图片 57

图片 58图片 59

  li=[‘小王’,‘小宁’, [a, b, [d, e, f ],  c ], ‘小张’]

图片 60

3.1.11 endswith()、startswith()

print(name.endswith(‘SB’))#认清是或不是以’SB’结尾 print(name.startswith(‘alex’))#剖断是还是不是以’alex’领头

 图片 61

# 3 删除并获取值
# dic = {
# “k1”: ‘v1’,
# “k2”: ‘v2’
# }
# v = dic.pop
# print
# k,v = dic.popitem()
# print

info = {"k1": "v1", "k2": "v2"}        键值对

貌似方法:

风度翩翩、数据类型

数据类型,相像类的值(钦定类的目的卡塔尔国具有同等的功用,成效保存在类中(独有生机勃勃份卡塔尔

1,构建列表,列表的要素得以分包其余数数据类型,能够是数字,字符串,列表,元组,字典,集结和布尔值

  v = ‘alex’ in li         print(li)

test='AleX'
v=test.lower()          #也表所有字母变小写,但是特殊字符表示不了。而capitalize()则对于很多未知的对应关系也可以表示
print(v)

5.1.1 append()

在列表尾巴部分增加三个值[改正自个儿值]

 图片 62

示例:

v = []
while True:
    name = input(“请输入顾客名:”)
    if name.lower() == ‘q’:
        break
    
v.append(name)
    print(v)

 图片 63

  1. 在钦命索引地点插入成分 ,方法为insert()

10、列表转变来字符串

 二者的区分为  若为 ② 则 .isdecimal 为false       . isdigit 为true   

6.1.4 嵌套

v =
(11,22,[11,22,33],33,(9,1,2,“alex”),44)#孙子不可变,儿子恐怕可变 v[2][1] = “xxxxx” print(v)
v[2].append(“asdasd”)
print(v)

 图片 64

图片 65图片 66

9、字符串调换来列表

 

5.1.7 sort()

排序

按ASCII码排序

 图片 67

图片 68

# 7 for循环
# dict
# info = {
# “k1”: 18,
# 2: True,
# “k3”: [
# 11,
# [],
# (),
# 22,
# 33,
# {
# ‘kk1’: ‘vv1’,
# ‘kk2’: ‘vv2’,
# ‘kk3’: ,
# }
# ],
# “k4”: (11,22,33,44)
# }
# for item in info:
# print
#
# for item in info.keys():
# print

3、能够经过索引取值,  恐怕切成丝取值(切条取值的结果也是列表卡塔 尔(英语:State of Qatar)

 三、列表list

7.2.3 设置

# key存在,则更新值
# key不设有,则创设键值对
v = {
    “k1”:‘v1’, # 键值对
    **
“k2”:‘v2’, # 键值对 }
v[
‘kk1’] = 666
v[
‘k1’**] = 777
print(v)

 图片 69

2,列表的在前边添比索素,方法为append()

   v = ‘ ‘.join(li)

name='苟陇辉'
 if '苟' in name:
    print('ok')
else:
    print('error')

 if '苟'not in name:
    print('ok')
else:
   print('error')

10、复数(complex类)

#复数 = #实数 #虚数

#复数 = 实部 + 虚部

#a+bj

 图片 70

二、元组成效及方式

1、 append追加

    li = [11,22,33,44]

错误方法: v = li.append('alex')
          print(v)      打印出来为none,说明v中为空
因为字符串不能修改,而列表可以直接修改,所以:可以直接写

          li.append('alex')
          print(li)  打印结果为:[...'alex']
  或者: li.append(['alex'])
      print(li)  打印结果为: [...['alex']] 

2、clear清空列表

    li.clear()
    print(li)


3、copy拷贝
    浅拷贝:v=li.copy()
                print(v)


4、count 计算元素出现的次数

    v = li.count(22)
    print(v)


5、extend 扩展原列表
   参数必须是:iterable可迭代对象(能被for循环)

         li.extend([1992,'xiaowang'])
         print(li)
         打印结果为:[...,1992, 'xiaowang']
或者   li.extend('小王同学')
         print(li)
         打印结果为:['小',‘王‘,‘同’, ’学’]    

6、index 获取当前值的索引位置(最左优先)
         v =  li.index(22)
         print(v)
     或者可以选取范围
         v=li.index('alex',1,3)

7、insert 指定索引位置插入元素
     li.insert(位置,插入的值)
     例如: li.insert(0,'alex')
                print(li)


》》》》》》》》》补充《》《》《》《》《》《》
源码中出现:    index索引,value值


8、pop 删除指定位置的值
    不指定索引时,默认删除最后一个值,并获取删除的值
        v = li.pop()
        print(li)
        print(v)
   指定索引时,删除指定位置的值,并获取删除的值
        v = li.pop(1)
        print(li)
        print(v)

9、remove 删除列表中的指定值,左边优先(括号内要填入删除的内容)
        li.remove(11)
        print(li)

10、reverse 反转,将当前列表进行反转
  li.reverse()
    print(li)

11、sort排序
   从小到大排序:
      li.sort()
   从大到小排序
      li.sort(reverse=True)
   欠两个参数:讲函数时补充 cmp, key

 

7.1.1 get()

轶闻key获取相应的值,key荒诞不经默许取None

 图片 71

意气风发、列表功能及方法

  “集结“,”内部能够停抛弃何事物

 

7.4 删除补充

毫不在循环当前字典的历程中,改善当前字典大小

# 题1:dic = {‘k1′:”v1″,’k2′:’v2’}把key=”k1″,键值对删除

 图片 72

# 题2:dic =
{‘u1′:”v1″,’k2′:’v2′,’k3′:’v3’}把key中存在k,键值对删除

错误:

 图片 73

正确:

# 正确方法 dic_key_list = []
for key in dic:
    dic_key_list.append(key)

for row in dic_key_list:
    if ‘k’ in row:
        del dic[row]
print(dic)

 图片 74

列表list在Python中实际就是一个类,赋值后正是调用这么些类的几个对象,list.xx()便是目的的方法,也可称之为参数。

    s=’ ‘

 

9、浮点数(float类)

#小数

    #有限小数

    #极致循环小数 3.33333 、4.404404

#Infiniti不循环小数  派

#浮点数

    #有限小数

#极致循环小数 3.33333 、4.404404

 图片 75

10、目录取值

2、列表中得以嵌套任何类型

5.v = dic.get(‘k1′,’111’)   
根据k获取值,key官样文章时,能够可钦赐输入结果 111 
 不钦定值时,暗许结果为none

4.7 示例

# 面试题 a = False or 2 > 3
print(a)
#有实际数字依然字符串时,输出数字或字符串 a = 9 or 2 > 3
print(a)
a = “asdf” or 2 > 3
print(a)

print

   tu = (11, ‘alex’,  ( 28, 29 ), 22, [33, 44 ], 55)

test='alexalex'
v=test.count('ex')      # 去字符串里寻找子序列('ex')出现的次数
print(v)

5.2.1 len()

总括列表长度

 图片 76

[33,22]

  s=’abcdefg’

test='Gou long hui'
v=test.istitle()        # 判断是否为标题(标题中每一个首字母都需大写)
print(v)
v=test.title()      # 转换为标题
print(v)

5.1.8 extend()

合并

 图片 77

View Code

  中括号括起来,

index   :   v = tu.index(111)   获取元素111  在tu中的索引    左侧优先

5、列表(list类)

可变的器皿,自身是转换的

图片 78图片 79

   print (v)

count=count%1 即 count%=1

7.1.3 values()

 图片 80

# 6 keys() 7 values() 8 items() get update
##########

  print(li[3])           print(li[3:-1])

 

8.1表现方式

name = b’alex’

name = b’\x12\x86\xdf\xdf\xa8\x34….’  #不在ascii表中的字符,中文字符

图片 81图片 82

1、查找字典内容

图片 83

3.1.18 expandtabs()

可以风流倜傥并换行符制表符使用,固定字符间隔长度

 图片 84

# \n ,换行符
# \t,制表符,相当于Tab缩进

View Code

  1、可通过索引取值,切丝取值

17、

5.2.2 索引

 图片 85

# 字典
# dict
# dict
# dic = {
# “k1”: ‘v1’,
# “k2”: ‘v2’
# }
# 1 根据系列,成立字典,并内定统生龙活虎的值
# v = dict.fromkeys([“k1″,123,”999”],123)
# print

        根据惯例平常在终极价格逗号来辨别

for item in li

11.2 功能

View Code

  若列表中的元素只有字符串,直接用字符串join方法

li = [11,22,33,22,44]
v = li.pop()                # 默认删除最后一个元素
print(li)                   # 获取删除后的列表
print(v)                    # 获取删除的值
li.pop(1)                   # 删除指定索引的元素
print(li)
print(li.pop(1))

li = [11,22,33,22,44]
li.remove(22)               # 删除指定的元素
print(li)

li.clear()                  # 清空列表
print(li)

11.2.1 add()

添加

 图片 86

  1. 依附值获取当前值索引地点方法为index

8、嵌套列表查询艺术

                 
②:顺序访谈(即索引卡塔 尔(阿拉伯语:قطر‎:字符串、列表、元祖

7.2.1 len()

 图片 87

[22, 33, 22, 44]
print

  print(li)

test='alex'
v=test.capitalize()         #表示首字母大写
print(v)

2、布尔型(bool类)

True 1

False 0

布尔值为False的情事:False : 0,None,”,{},[],()

[11, 22, 33, 22]

一、列表—-list

特例:test.splitlines() 
表示依据换行符‘\n’分割      test.splitlines(True) 则展现换行符‘\n’,
test.splitlines(False),则不呈现换行符‘\n’。

8、字节(bytes类)

bytes

诚如互联网传输和硬盘存款和储蓄使用bytes类型

# 1、基本机构
# info = {
# “k1”: “v1”, # 键值对
# “k2”: “v2”
# }
#### 2 字典的value能够是其它值
# info = {
# “k1”: 18,
# “k2”: True,
# “k3”: [
# 11,
# [],
# (),
# 22,
# 33,
# {
# ‘kk1’: ‘vv1’,
# ‘kk2’: ‘vv2’,
# ‘kk3’: ,
# }
# ],
# “k4”: (11,22,33,44)
# }
# print

3、因为是可迭代对象:字符串、列表、元祖能够互相调换

li=[‘123′,’alex’]

11.1 性质

晤面的要素无重复,能够做快速去重的章程

会集是可变数据类型

会集内部不能够加可变数据类型,如列表,列表

汇聚内部因素时不可变数据类型

集结内部不能够嵌套集合

 

  1. 去除列表中的钦点值,左侧优先 方法remove()
    li = [11, 22, 33, 22, 44]
    li.remove
    print

=====================list类中提供的法子===================

 

4.6 bool–>int

True–1

False–0

 图片 88

图片 89

[11, 22, 33, 22, 44, [77, 99]]>>> li = [11, 22, 33, 22, 44]>>> li.index(22)1        只查到第一个元素22所在的索引位置

         
列表是一动不动的,列表成分能够被涂改

二、字符型

3.1.17 count()

计量个数

 图片 90

三、字典的职能和方法

      s=s+str(i)

 

11.2.5 intersection()、intersection_update()

求交集

intersection()

不修改原集结,更换之后的集结赋给三个新的变量

intersection_update()

直白更改原会集

 图片 91

# 6 字典扶植 del 删除
# info = {
# “k1”: 18,
# 2: True,
# “k3”: [
# 11,
# [],
# (),
# 22,
# 33,
# {
# ‘kk1’: ‘vv1’,
# ‘kk2’: ‘vv2’,
# ‘kk3’: ,
# }
# ],
# “k4”: (11,22,33,44)
# }
# del info[‘k1’]
#
# del info[‘k3’][5][‘kk1’]
# print

4、extend扩充,在元祖中近似适用

注:在Python3中,不论数字多大,都归属int类型;在Python第22中学,数字变大,超越一定约束则称为long型;

11.2.6 union()

求并集

 图片 92

5.
扩充原列表,参数:可迭代对象,方法为extend()会把叁个可迭代的目的,迭代出来作为元素加入到列表中,也正是替我们用For循环每一个参与到列表。

5、元祖的拔尖成分不可被改换,元祖中嵌套的列表能够被涂改

print(a)

5.1.2 insert()

在内定地点插入数据

v = [11,22,33,44,“蒋毅”]
v.insert(4,“孙骑兵”)#4是下标 print(v)

 图片 93

li = [11, 22, 33, 22, 44]
print 取值的目录范围大于等2,小于4.

》》》》》》》》两个方法《》《》《》《》《》《
count 获取指定元素在元祖中出现的次数
index 获取某个指定元素的索引,可以设定起始位置查找

 一、整形  int   

7.2.5 循环

for

 图片 94

# for item in info.keys():
# print(item,info[item])

  li = list(s)

for (k,v) in info.items()     
 循环K,V

7.1.5 update()

合并四个字典,借使有重复键则归并值,没有再一次的键则增多值

 图片 95

图片 96

  1. 总括成分现身的次数
    v = li.count
    print

  成分不可被改变,且元素不可能被扩张或然去除,但是能够被查看

           ‘k2’:true

7.3 示例

# 示例: user_list = [
    {‘name’:‘老头’,‘age’: 18},
    {‘name’:‘流量’,‘age’: 66},
    {‘name’:‘wifi’,‘age’: 99},
]

n = input(“请输入人名:”)
a = input(“请输入年龄:”)
temp = {‘name’: n, ‘age’: int(a)}
user_list.append(temp)
for item in user_list:
    print(item[‘name’],item[‘age’])

 图片 97

8、 删除某些值(1.点名索引;2. 暗许最后三个),并得到删除的值
li = [11, 22, 33, 22, 44]
v = li.pop()
print

5、元祖是有序的

图片 98

7.2.6 嵌套

val = {
    ‘k1’: 123,
    ‘k2’: “asdf”,
    ‘k3’: True,
    ‘k4’: [11,22,33],
    ‘k5’: (1,2,3),
    ‘k6’: {
        ‘kk1’:‘vv1’,
        ‘kk2’:‘vv2’,
    },
    ‘k7’: [1,2,(8,6,2),{“k111”:‘vvv1’},5]
}

 

元组,成分不可被退换,不可能被增加依旧去除
tuple
tu = (11,22,33,44)
tu.count,获取内定成分在元组中现身的次数
tu.index

 

图片 99

1、整数(int类)

   1,2,3,4…….99….

li = [11, 22, 33, 22, 44]li.append([9898,"不得了"])print

 

replace      v=test.replace(‘ex’,’bbb’,2) 
 2为轮番前2个

5.1.3 reverse()

v = [11,22,33,44]
print(v)
v.reverse()
print(v)

 图片 100

li = [11, 22, 33, 22, 44]
v = li.pop
print

  li = [‘xiaozhang’, ‘xiaowang’]

test='苟陇辉五六七八九'
v='_'.join(test)        # 将字符串中的每一个元素按照指定分隔符拼接。 注意    .join
print(v)

11.2.2 difference()、difference_update()

差集

difference()

不改进原集结,改造之后的集合赋给一个新的变量

 图片 101

difference_update()

直白改动原集结

 图片 102

#### 3 布尔值、列表、字典无法看做字典的key
# info ={
# 1: ‘asdf’,
# “k1”: ‘asdf’,
# True: “123”,
# # [11,22]: 123
# : 123,
# # {‘k1′:’v1’}: 123
#
# }
# print

  print(li[2][2][0])

7、

4.2 str–>bool

空值字符串–False

其他–True

 图片 103

图片 104

图片 105图片 106

图片 107

7、字典(dict类)

# 5 更新
# dic = {
# “k1”: ‘v1’,
# “k2”: ‘v2’
# }
# dic.update({‘k1’: ‘111111’,’k3′: 123})
# print
# dic.update(k1=123,k3=345,k5=”asdf”)
# print

2、in 操作

11.2.8 issubset()、issuperset()

issubset() 是不是是子集

issuperset()是还是不是是父集

 图片 108

# 4 设置值,
# 已存在,不设置,获取当前key对应的值
# 子虚乌有,设置,获取当前key对应的值
# dic = {
# “k1”: ‘v1’,
# “k2”: ‘v2’
# }
# v = dic.setdefault(‘k1111′,’123’)
# print

概念:①:分歧因素构成

11.2.7 isdisjoint()

看清是还是不是无交集

 图片 109

图片 110图片 111

2、取值:据K取值,即据索引取到钦赐元素,但不足使用切成条(因为字典是冬日的卡塔尔国。

3.1.19 index()

列表字符的目录

 图片 112

# True 1 False 0
# info ={
# “k1”: ‘asdf’,
# True: “123”,
# # [11,22]: 123
# : 123,
# # {‘k1′:’ v1′}: 123
#
# }
# print

test='tuys'
v=test.isalpha()        # 判断字符串是否只包含字母 汉字
print(v)

7.2.2 获取

 图片 113

# 4 字典冬日

14、

3.1.15 casefole()

字符串变小写,满含小语种,lower()只可以改成立陶宛语

 图片 114

# for item in info.values():
# print

 

3.1.16 center(),ljust(),rjust()

center():两侧补字符

ljust():左侧补字符

rjust():侧边补字符

 图片 115

11

魔法  

3.1.10 join()

三番五回列表的成分

 图片 116

name='苟陇辉'
v= '苟' in name
print(v)

user='alex'
pwd=123
v=user=='alex' and pwd==124 or user=='ales'and pwd=='123' print(v)

4.4 int–>bool

0–False

其他–True

 图片 117

  print(item)

3、字符串(str类)

字符串调用函数时,字符串本人原值不改变

        

7.2 公共职能

16、

6.1.3 循环

for

 图片 118

可变:列表,字典

3.1.20 isdigit()

推断字符串的内容是还是不是是纯数字

 图片 119

 

4.5 bool–>str

str(bool)

li = [11,22,33,22,44]
li.reverse()                        # 将当前列表进行反转
print(li)
li.sort()                           # 排序,从小到大排序
print(li)
li.sort(reverse=True)               # 从大到小排序
print(li)

11.2.9 pop()、remove()、discard()

去除会集的因素

pop()

删去成分并回到该因素

 图片 120

remove()

去除,借使成分空头支票会报错

 图片 121

discard()

删去,假若成分子虚乌有不会报错

 图片 122

 

7.1 dict类中提供的效劳

test='aLex'
v=test.center(20,'*')       # 表示  设置宽度,并将内容居中,其中20代表总长度,'*'代表空白处的未知填充,只能有一个字符,可有可无
print(v)

5.1 list类中提供的效应