Python运算符及基本数据类型,字典小记

By admin in 4858.com on 2019年2月12日

一、列表功能及措施

1、算数运算符:

一、数据类型

数据类型,相同类的值(指定类的目的)具有同样的成效,作用保存在类中(唯有一份)

一、数据类型

数据类型,相同类的值(指定类的目的)具有同样的听从,功效保存在类中(唯有一份)

1,建立列表,列表的因素得以包罗其他数数据类型,可以是数字,字符串,列表,元组,字典,集合和布尔值

+   –  *  /   **    %  //  

1、整数(int类)

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

1、整数(int类)

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

4858.com 14858.com 2

num=9%2

bit_length()

眼下十进制用二进制表示时,最少使用的位数

 

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

 4858.com 3

bit_length()

此时此刻十进制用二进制表示时,最少使用的位数

 

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

 4858.com 4

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

print(num)

2、布尔型(bool类)

True 1

False 0

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

2、布尔型(bool类)

True 1

False 0

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

View Code

num=9%2
print(num)


num=9//2
print(num )

3、字符串(str类)

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

3、字符串(str类)

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

列表list在Python中实际就是一个类,赋值后就是调用这些类的一个目的,list.xx()就是目的的不二法门,也可称为参数。

2、成员运算

3.1 字符串提供的机能

3.1.1 upper()

变大写

 4858.com 5

3.1.2 lower()

变小写

 4858.com 6

3.1.3 capitalize()

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

 4858.com 7

3.1.4 strip()

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

 4858.com 8

示例:

 4858.com 9

3.1.5 lstrip()

删除右侧空格

 4858.com 10

3.1.6 rstrip()

剔除右侧空格

 4858.com 11

3.1.7 replace()

替换

 4858.com 12

4858.com 13

 

 4858.com 14

4858.com 15

3.1.8 split()

分割

 4858.com 16

4858.com 17

4858.com 18

4858.com 19

3.1.9 isdecimal()

判断当前字符串中是还是不是全体都是数字

 4858.com 20

示例:

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

 4858.com 21

 

3.1 字符串提供的效应

3.1.1 upper()

变大写

 4858.com 22

3.1.2 lower()

变小写

 4858.com 23

3.1.3 capitalize()

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

 4858.com 24

3.1.4 strip()

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

 4858.com 25

示例:

 4858.com 26

3.1.5 lstrip()

去除右侧空格

 4858.com 27

3.1.6 rstrip()

除去左边空格

 4858.com 28

3.1.7 replace()

替换

 4858.com 29

4858.com 30

 

 4858.com 31

4858.com 32

3.1.8 split()

分割

 4858.com 33

4858.com 34

4858.com 35

4858.com 36

3.1.9 isdecimal()

判断当前字符串中是或不是全体都以数字

 4858.com 37

示例:

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

 4858.com 38

 

2,列表的在背后添台币素,方法为append()

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

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

3.1.10 join()

连日列表的要素

 4858.com 39

3.1.10 join()

总是列表的因素

 4858.com 40

4858.com 414858.com 42

in             not in   判断某个东西是还是不是在某个东西中富含。

3.1.11 endswith()、startswith()

print(name.endswith(‘SB’))#判断是还是不是以’SB’结尾 print(name.startswith(‘alex’))#认清是或不是以’alex’最先

 4858.com 43

3.1.11 endswith()、startswith()

print(name.endswith(‘SB’))#判断是或不是以’SB’结尾 print(name.startswith(‘alex’))#认清是还是不是以’alex’开端

 4858.com 44

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

3、逻辑运算

3.1.12 encode(‘utf-8或gbk’)

把字符串转化成字节

 4858.com 45

4858.com 46

3.1.12 encode(‘utf-8或gbk’)

把字符串转化成字节

 4858.com 47

4858.com 48

View Code

布尔值:  结果 为‘真’  true   或者 结果为 
‘假’  false

3.1.13 find()、index()

find()

在字符串中搜索,找不到再次回到-1

 4858.com 49

 

index()

在字符串中查找,找不到报错

 4858.com 50

3.1.13 find()、index()

find()

在字符串中检索,找不到重返-1

 4858.com 51

 

index()

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

 4858.com 52

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

# ” 空字符为假

3.1.14 format()

格式化字符串

(1)

 4858.com 53

(2)

 4858.com 54

(3)

 4858.com 55

(4)

 4858.com 56

3.1.14 format()

格式化字符串

(1)

 4858.com 57

(2)

 4858.com 58

(3)

 4858.com 59

(4)

 4858.com 60

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

# ‘   ‘  只要其中有东西 就为真

3.1.15 casefole()

字符串变小写,包罗小语种,lower()只可以改变英文

 4858.com 61

3.1.15 casefole()

字符串变小写,包涵小语种,lower()只可以改变英文

 4858.com 62

 4. 盘算成分现身的次数
 v = li.count(22)
 print(v)

#  0    假

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

center():两边补字符

ljust():左侧补字符

rjust():左侧补字符

 4858.com 63

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

center():两边补字符

ljust():右侧补字符

rjust():左边补字符

 4858.com 64

5.
增加原列表,参数:可迭代对象,方法为extend()会把一个可迭代的对象,迭代出来作为成分参加到列表中,也等于替我们用For循环每种投入到列表。

# 其他  真

3.1.17 count()

总括个数

 4858.com 65

3.1.17 count()

计量个数

 4858.com 66

4858.com 674858.com 68

  ‘转换bool值     

3.1.18 expandtabs()

可以协同换行符制表符使用,固定字符间隔长度

 4858.com 69

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

3.1.18 expandtabs()

可以同步换行符制表符使用,固定字符间隔长度

 4858.com 70

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

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

a=123

3.1.19 index()

列表字符的目录

 4858.com 71

3.1.19 index()

列表字符的目录

 4858.com 72

View Code

b=bool(a )’

3.1.20 isdigit()

看清字符串的情节是还是不是是纯数字

 4858.com 73

3.1.20 isdigit()

判定字符串的内容是还是不是是纯数字

 4858.com 74

出口结果为:

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

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

3.1.21 isalpha()

判定字符串的内容是不是是纯字母

 4858.com 75

3.1.21 isalpha()

看清字符串的始末是还是不是是纯字母

 4858.com 76

4858.com 774858.com 78

4、赋值运算

3.1.22 isspace()

 4858.com 79

3.1.22 isspace()

 4858.com 80

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

count=1

3.2 公共职能

3.2.1 len()

计算当前字符串长度

 4858.com 81

 

3.2.2 索引、下标

#      –  单个值:v[0]

#      –  多个值:v[先河地方:截至地方]

#      –  多个值:v[起先地点:为止地点:步长]

#      PS: -1表示最终

 4858.com 82

4858.com 83

4858.com 84

4858.com 85

示例:

*# 题: 列出v = “ASCII第五遍以规范标准的型态发”
# v = “ASCII第几次以正规化标准的型态发”
# length = len(v)
# index = 0
# while True:
#     data = v[index]
#     print(data)
#     index += 1
#     if index == length:
#         break

*v = “ASCII第几回以专业标准的型态发” length = len(v)
index = 0
while index < length:
    data = v[index]
    print(data)
    index += 1

 

 

3.2.3 循环 

4858.com 86

4858.com 87

 

3.2 公共职能

3.2.1 len()

计量当前字符串长度

 4858.com 88

 

3.2.2 索引、下标

#      –  单个值:v[0]

#      –  多个值:v[起始地方:停止地方]

#      –  多个值:v[开场地点:停止地方:步长]

#      PS: -1表示最终

 4858.com 89

4858.com 90

4858.com 91

4858.com 92

示例:

*# 题: 列出v = “ASCII第三遍以专业标准的型态发”
# v = “ASCII第三遍以标准标准的型态发”
# length = len(v)
# index = 0
# while True:
#     data = v[index]
#     print(data)
#     index += 1
#     if index == length:
#         break

*v = “ASCII第一遍以正规化标准的型态发” length = len(v)
index = 0
while index < length:
    data = v[index]
    print(data)
    index += 1

 

 

3.2.3 循环 

4858.com 93

4858.com 94

 

View Code

count=count+1  即  count+=1

4、int-bool-str转换

int    89  90

bool   True False

str  ‘sdf’ ‘7’

4、int-bool-str转换

int    89  90

bool   True False

str  ‘sdf’ ‘7’

 

count=count%1 即 count%=1

4.1 str–>int

示例:

#加法总括器 v1 = input(“请输入第四个值:”) # “54” v2 = input(“请输入首个值:”)
v3 = int(v1) + int(v2)
print(v3)

 4858.com 95

4.1 str–>int

示例:

#加法总括器 v1 = input(“请输入首个值:”) # “54” v2 = input(“请输入第四个值:”)
v3 = int(v1) + int(v2)
print(v3)

 4858.com 96

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

5、比较运算

4.2 str–>bool

空值字符串–False

其他–True

 4858.com 97

4858.com 98

4.2 str–>bool

空值字符串–False

其他–True

 4858.com 99

4858.com 100

4858.com 1014858.com 102

a= 1>5

4.3 int–>str

str(int)

 4858.com 103

4.3 int–>str

str(int)

 4858.com 104

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

print(a)

4.4 int–>bool

0–False

其他–True

 4858.com 105

4.4 int–>bool

0–False

其他–True

 4858.com 106

View Code

结果为 false

4.5 bool–>str

str(bool)

4.5 bool–>str

str(bool)

它与append的歧异在于,append会把任何输入对象作为一个要素加入到列表的末端。

 

4.6 bool–>int

True–1

False–0

 4858.com 107

4858.com 108

4.6 bool–>int

True–1

False–0

 4858.com 109

4858.com 110

 

总计: 算数运算符 和 赋值运算符 得到的均为‘’真实‘’结果;相比较运算符、
逻辑运算符、成员运算拿到的结果均为“布尔值”

4.7 示例

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

4.7 示例

# 面试题 a = False or 2 > 3
print(a)
#有切实可行数字如故字符串时,输出数字或字符串 a = 9 or 2 > 3
print(a)
a = “asdf” or 2 > 3
print(a)

  1. 基于值获取当前值索引地点(右侧优先)方法为index(xx)

中央数据类型

5、列表(list类)

可变的器皿,本身是生成的

5、列表(list类)

可变的器皿,自己是转变的

4858.com 1114858.com 112

 一、整形  int   

5.1 list类中提供的效应

5.1 list类中提供的意义

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

注:在Python3中,无论数字多大,都属于int类型;在Python2中,数字变大,超越一定限制则称之为long型;

5.1.1 append()

在列表底部扩展一个值[修改本人值]

 4858.com 113

示例:

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

 4858.com 114

5.1.1 append()

在列表尾部伸张一个值[修改自身值]

 4858.com 115

示例:

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

 4858.com 116

View Code

魔法  

5.1.2 insert()

在指定位置插入数据

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

 4858.com 117

5.1.2 insert()

在指定地点插入数据

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

 4858.com 118

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

1、转换职能

5.1.3 reverse()

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

 4858.com 119

5.1.3 reverse()

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

 4858.com 120

4858.com 1214858.com 122

a='123'
print(type(a),a)     # type 查看类型 
b=int(a)             # 将字符串'123',转换为数字123
print(type(b),b)

5.1.4 remove()、del、pop()

删除

 4858.com 123

pop()不指定地方默认删除最后一个,再次来到删除成分的值

 4858.com 124

5.1.4 remove()、del、pop()

删除

 4858.com 125

pop()不指定地方暗中同意删除最终一个,再次回到删除成分的值

 4858.com 126

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

4858.com 127

5.1.5 index()

找参数的岗位

 4858.com 128

5.1.5 index()

找参数的职位

 4858.com 129

View Code

a='0011'
v=int(a ,base=2)    # base=16/8/2  指代以16进制数,8进制数,2进制数表示a, 若是不写base=  则默认10进制数
print(v)

5.1.6 clear()

清空列表

 4858.com 130

5.1.6 clear()

清空列表

 4858.com 131

 8、 删除某个值(1.指定索引;2. 暗中认同最终一个),并拿到删除的值
li = [11, 22, 33, 22, 44]
v = li.pop()
print(li)

4858.com 132

5.1.7 sort()

排序

按ASCII码排序

 4858.com 133

4858.com 134

5.1.7 sort()

排序

按ASCII码排序

 4858.com 135

4858.com 136

[11, 22, 33, 22]

2、

5.1.8 extend()

合并

 4858.com 137

5.1.8 extend()

合并

 4858.com 138

print(v)

age=10
r=age.bit_length()    #表示当前数字的二进制,至少用多少位表示  10的二进制数为1010 即4位
print(r)

5.1.9 copy()

复制、浅拷贝

 4858.com 139

有一个风味:浅copy,只copy第一层

现行的急需是要出口的names2与第一行names定义的一模一样

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

 4858.com 140

name1 =
[“zhangyang”,“guyun”Python运算符及基本数据类型,字典小记。,“xiangpeng”,[“jack”,“alex”],“xulang”]
name2 = name1.copy()
name1[1] = “古云” name1[3][0] = “杰克” print(name1)
print(name2)

 4858.com 141

列表的特色

 4858.com 142

与字符串或数字不相同

 4858.com 143

深拷贝

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

 4858.com 144

简述深浅拷贝

#一旦拷贝单层列表时,深浅拷贝都把原列表拷贝到了一个新的内存地址,所以原列表被改动新列表都不会被改动

#如果拷贝多层列表时

    #浅拷贝只将原列表的率先层拷贝到了新的内存地址,新列表二层及以内的依然指向原列表的内存地址,所以原列表被修改,新列表的

    #第一层不会变动,二层及以内的会随之新列表修改

    #深拷贝是将原列表的兼具都拷贝到了新的内存地址,原列表被修改,新列表不会变动

5.1.9 copy()

复制、浅拷贝

 4858.com 145

有一个特色:浅copy,只copy第一层

后天的须要是要出口的names2与第一行names定义的同等

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

 4858.com 146

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

 4858.com 147

列表的特点

 4858.com 148

与字符串或数字不一致

 4858.com 149

深拷贝

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

 4858.com 150

简述深浅拷贝

#万一拷贝单层列表时,深浅拷贝都把原列表拷贝到了一个新的内存地址,所以原列表被改动新列表都不会被改动

#只要拷贝多层列表时

    #浅拷贝只将原列表的率先层拷贝到了新的内存地址,新列表二层及以内的照样指向原列表的内存地址,所以原列表被改动,新列表的

    #先是层不会变动,二层及以内的会随之新列表修改

    #深拷贝是将原列表的有着都拷贝到了新的内存地址,原列表被改动,新列表不会转移

44

4858.com 151

5.2 公共职能

5.2 公共职能

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

二、字符型

5.2.1 len()

算算列表长度

 4858.com 152

5.2.1 len()

计量列表长度

 4858.com 153

 [22, 33, 22, 44]
 print(v)

魔法 

5.2.2 索引

 4858.com 154

5.2.2 索引

 4858.com 155

11

1、

5.2.3 循环

for

 4858.com 156

5.2.3 循环

for

 4858.com 157

  1. 去除列表中的指定值,左侧优先  方法remove()
    li = [11, 22, 33, 22, 44]
    li.remove(22)
    print(li)
test='alex'
v=test.capitalize()         #表示首字母大写
print(v)

5.2.4 替换

 4858.com 158

5.2.4 替换

 4858.com 159

[11,  33, 22, 44]     只删除第四个要素22
PS: pop 暗许从最后一个剔除, remove私行认同左侧优先,  del
li[0] 删除指定索引地点的因素   del li[7:9] 切片整段删除, 
clear清空列表。

4858.com 160

5.2.5 删除

del

 4858.com 161

4858.com 162

5.2.5 删除

del

 4858.com 163

4858.com 164

 

2、

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)

 4858.com 165

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)

 4858.com 166

10、 索引取值

test='AleX'
v=test.casefold()          #表所有字母变小写
print(v)

5.3 删除补充

除去列表成分时,会影响列表长度,从而使得索引取值时,简单并发错误。

 4858.com 167

缓解方法:

# 化解方案一: 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)

 4858.com 168

# 化解方案二: 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)

 4858.com 169

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

 4858.com 170

5.3 删除补充

剔除列表成分时,会影响列表长度,从而使得索引取值时,简单现身错误。

 4858.com 171

杀鸡取卵措施:

# 消除方案一: 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)

 4858.com 172

# 消除方案二: 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)

 4858.com 173

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

 4858.com 174

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

4858.com 175

6、元组(tuple类)

不可变的器皿

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

6、元组(tuple类)

不可变的器皿

唯有一个成分时,一定加逗号(1,)

print(li[3])

注意:

6.1 公共职能

6.1 公共职能

33

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

6.1.1 len()

 4858.com 176

6.1.1 len()

 4858.com 177

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

4858.com 178

6.1.2 索引

 4858.com 179

6.1.2 索引

 4858.com 180

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

3、

6.1.3 循环

for

 4858.com 181

6.1.3 循环

for

 4858.com 182

[33,22]

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

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)

 4858.com 183

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)

 4858.com 184

 

4858.com 185

7、字典(dict类)

7、字典(dict类)

二、元组成效及措施

标准为:test.center(width,fillchar=None)

7.1 dict类中提供的作用

7.1 dict类中提供的功能

元组,成分不可被修改,不可以被伸张恐怕去除
tuple
tu = (11,22,33,44)
tu.count(22),获取指定成分在元组中出现的次数
tu.index(22)

4、

7.1.1 get()

依照key获取相应的值,key不设有暗中同意取None

 4858.com 186

7.1.1 get()

据悉key获取相应的值,key不设有暗中同意取None

 4858.com 187

三、字典的意义和章程

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

7.1.2 keys()

 4858.com 188

7.1.2 keys()

 4858.com 189

# 字典
# dict
# dict
# dic = {
# “k1”: ‘v1’,
# “k2”: ‘v2’
# }
# 1 依据体系,创立字典,并点名统一的值
# v = dict.fromkeys([“k1″,123,”999”],123)
# print(v)

 4858.com 190

7.1.3 values()

 4858.com 191

7.1.3 values()

 4858.com 192

# 2 依照Key获取值,key不设有时,可以指定暗许值(None)
# v = dic[‘k11111’]
# print(v)
# v = dic.get(‘k1’,111111)
# print(v)

test='alexalex'
v=test.count('ex',5,8)      # 去字符串里寻找子序列('ex')出现的次数,指定寻找的起始 和 结束 位置  注意字符串第一位为0
print(v)

7.1.4 items()

 4858.com 193

7.1.4 items()

 4858.com 194

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

4858.com 195

7.1.5 update()

联合多少个字典,如果有重复键则合并值,没有再次的键则添加值

 4858.com 196

4858.com 197

7.1.5 update()

集合五个字典,假若有重复键则合并值,没有重新的键则添加值

 4858.com 198

4858.com 199

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

5、

7.2 公共职能

7.2 公共职能

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

test='alex'
v=test.endswith('ex')      #  字符串以什么结尾 
print(v)                   #  v=test.startswith('a') 表示字符串以什么开头   

7.2.1 len()

 4858.com 200

7.2.1 len()

 4858.com 201

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

4858.com 202

7.2.2 获取

 4858.com 203

7.2.2 获取

 4858.com 204

 

6、

7.2.3 设置

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

 4858.com 205

7.2.3 设置

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

 4858.com 206

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

test='alexalex'
v=test.find('ex',5,8)       # 从开始往后找,获取其位置 ,可指定其寻找的起始位置,注意,大于等于5,小于8
print(v)

7.2.4 删除

del

 4858.com 207

7.2.4 删除

del

 4858.com 208

#### 3 布尔值(1,0)、列表、字典不大概当做字典的key
# info ={
# 1: ‘asdf’,
# “k1”: ‘asdf’,
# True: “123”,
# # [11,22]: 123
# (11,22): 123,
# # {‘k1′:’v1’}: 123
#
# }
# print(info)

4858.com 209

7.2.5 循环

for

 4858.com 210

7.2.5 循环

for

 4858.com 211

# 4 字典无序

小心:找不到时 结果为-1

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]
}

 

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]
}

 

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

7、

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’])

 4858.com 212

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’])

 4858.com 213

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

test='alexalex'
v=test.index('8')           #  从开始往后找,获取其位置 ,可指定其寻找的起始位置,找不到时程序报错,故一般使用find命令,找不到时 运行结果为-1
print(v)

7.4 删除补充

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

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

 4858.com 214

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

错误:

 4858.com 215

正确:

# 正确方法 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)

 4858.com 216

7.4 删除补充

不要在循环当前字典的经过中,修改当前字典大小

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

 4858.com 217

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

错误:

 4858.com 218

正确:

# 正确方法 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)

 4858.com 219

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

4858.com 220    程序报错

8、字节(bytes类)

bytes

相似网络传输和硬盘存储使用bytes类型

8、字节(bytes类)

bytes

一般网络传输和硬盘存储使用bytes类型

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

8、

8.1表现方式

name = b’alex’

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

8.1表现方式

name = b’alex’

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

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

test='i am {name},age{a}'
v=test.format(name='alex',a=19)     # 格式化,将一个字符串的占位符替换为指定的值。注意格式的准确性,括号必须为大括号
print(v)

8.2之中原理

在硬盘内部存储以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

 4858.com 221

8.2里边原理

在硬盘内部存储以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

 4858.com 222

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

4858.com 223

9、浮点数(float类)

#小数

    #有限小数

    #极端循环小数 3.33333 、4.404404

#无限不循环小数  派

#浮点数

    #有限小数

#最为循环小数 3.33333 、4.404404

 4858.com 224

9、浮点数(float类)

#小数

    #有限小数

    #极端循环小数 3.33333 、4.404404

#无限不循环小数  派

#浮点数

    #有限小数

#最为循环小数 3.33333 、4.404404

 4858.com 225

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

test='i am {name},age{a}'
v=test.format_map({'name':'alex','a':19})     # 也是格式化,将一个字符串的占位符替换为指定的值。注意格式的准确性,冒号不能少
print(v)

10、复数(complex类)

#复数 = #实数 #虚数

#复数 = 实部 + 虚部

#a+bj

 4858.com 226

10、复数(complex类)

#复数 = #实数 #虚数

#复数 = 实部 + 虚部

#a+bj

 4858.com 227

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

4858.com 228

11、集合(set类)

11、集合(set类)

9、

11.1 性质

聚集的要素无重复,能够做快捷去重的主意

聚拢是可变数据类型

会晤内部不恐怕加可变数据类型,如列表,列表

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

集结内部不大概嵌套集合

 

11.1 性质

聚拢的成分无重复,可以做火速去重的主意

会见是可变数据类型

会聚内部无法加可变数据类型,如列表,列表

集结内部因素时不可变数据类型

聚拢内部不能嵌套集合

 

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

11.2 功能

11.2 功能

4858.com 229

11.2.1 add()

添加

 4858.com 230

11.2.1 add()

添加

 4858.com 231

10、

11.2.2 difference()、difference_update()

差集

difference()

不改动原集合,改变以往的集合赋给一个新的变量

 4858.com 232

difference_update()

直接修改原集合

 4858.com 233

11.2.2 difference()、difference_update()

差集

difference()

不改动原集合,改变以往的集合赋给一个新的变量

 4858.com 234

difference_update()

向来修改原集合

 4858.com 235

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

11.2.3 symmetric_difference()、symmetric_difference_update()

清除三个汇聚同时存在的值

symmetric_difference()

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

symmetric_difference_update()

平素改动原集合

 4858.com 236

11.2.3 symmetric_difference()、symmetric_difference_update()

破除三个会聚同时设有的值

symmetric_difference()

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

symmetric_difference_update()

直白改动原集合

 4858.com 237

4858.com 238

11.2.4 dicard()

在汇聚中删去制定值

 4858.com 239

11.2.4 dicard()

在会聚中剔除制定值

 4858.com 240

11、

11.2.5 intersection()、intersection_update()

求交集

intersection()

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

intersection_update()

一向改动原集合

 4858.com 241

11.2.5 intersection()、intersection_update()

求交集

intersection()

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

intersection_update()

直白改动原集合

 4858.com 242

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

11.2.6 union()

求并集

 4858.com 243

11.2.6 union()

求并集

 4858.com 244

4858.com 245

11.2.7 isdisjoint()

看清是或不是无交集

 4858.com 246

11.2.7 isdisjoint()

判断是还是不是无交集

 4858.com 247

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

11.2.8 issubset()、issuperset()

issubset() 是还是不是是子集

issuperset()是不是是父集

 4858.com 248

11.2.8 issubset()、issuperset()

issubset() 是还是不是是子集

issuperset()是或不是是父集

 4858.com 249

4858.com 250

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

删除集合的要素

pop()

剔除元素并再次来到该因素

 4858.com 251

remove()

除去,若是成分不存在会报错

 4858.com 252

discard()

删除,假诺成分不存在不会报错

 4858.com 253

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

去除集合的成分

pop()

删去成分并赶回该因素

 4858.com 254

remove()

删除,纵然成分不存在会报错

 4858.com 255

discard()

去除,如若成分不设有不会报错

 4858.com 256

 

11.2.10 update()

更新

 4858.com 257

11.2.10 update()

更新

 4858.com 258

 二者的界别为  若为 ② 则 .isdecimal 为false       . isdigit 为true   

11.2.11 for循环

 4858.com 259

11.2.11 for循环

 4858.com 260

test='二2②'
v=test.isnumeric()      # 判断是否全为数字  可识别汉字
print(v)

11.2.12 len()

长度

 4858.com 261

11.2.12 len()

长度

 4858.com 262

 4858.com 263

11.3 各种型转换

 4858.com 264

 

11.3 各种型转换

 4858.com 265

 

 

.isnumeric 也可识别 汉字‘二’

12、

test='_123rt'
v=test.isidentifier()       # 判断 标识符 格式是否正确  注意:标识符同字符串规则一样,不能使用数字开头
print(v)

 4858.com 266

13、

test='\totijd\n'
v=test.isprintable()        # 判断是否存在不可见的(如\n、\t) ,或运行结果不可显示的字符  
print(v)

4858.com 267

14、

test='    '
v=test.isspace()        # 判断是否字符串全为空格
print(v)

4858.com 268

15、

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

4858.com 269

16、

test='aeiou'
test1='12345'   #  获得对应关系
v='asidou'
v1=str.maketrans('aeiou','12345')       # 替换功能
new_v=v.translate(v1)
print(new_v)

4858.com 270

17、

test='aLEx'
v=test.swapcase()       # 大小写转换
print(v)

4858.com 271

17、

test='username\temail\tpassword\ngoulonghui\tglh020@qq.com\t123\nweiguoquan\tweiguoquan@qq.com\t234'
v=test.expandtabs(20)       # 从开始往后找制表符'\t',20个一组,找到后用空格自动补齐20,可用于制作表格
print(v)

4858.com 272

 

必背魔法:

1、

test='alexex'
v=test.find('ex')       # 从开始往后找,找到第一个之后,获取其位置
print(v)

 

4858.com 273

test='alexex'
v=test.rfind('ex',2,5)      # 从右往左找,规定范围在>=2,<5,之间,获取其位置, 注意:无论从左往右还是,从右往左数,都是左边第一个字符 索引为0
print(v)

4858.com 274

 

2、

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

4858.com 275

3和4 、

test='ALex'
v1=test.islower()       # 判断字符串是否全为小写
v2=test.lower()         # 将字符串全部转换为小写
v3=test.isupper()       # 判断字符串是否全为大写
v4=test.upper()         # 将字符串全部转换为大写
print(v1,v2,v3,v4)

4858.com 276

5、

test='  xalex  '
test1='al\te\tx'
# v1=test.lstrip()          # 去除左边空格
# v2=test1.lstrip()         # 去除‘\t’‘\n’
# v3=test.rstrip()          # 去除右边空格
# v4=test1.rstrip()         # 去除‘\t’‘\n’
# v5=test.strip()           # 去除所有空格
# v6=test1.strip()          # 去除‘\t’‘\n’
test2='xalex'
v7=test2.lstrip('xa')       # 去除指定字符
print(v7)


6、

test='testasdsddfg'
v1=test.partition('s')      # 以目标's'分割,找到第一个s后分,只能分割三块
v2=test.rpartition('s')     # 以目标's'分割,从右找 找到第一个s后分,只能分割三块
v3=test.split('s',)         # 以目标's'分割,找到第一个s后分,但是不显示分割字符s
v4=test.rsplit('s')         # 以目标's'分割,从右找到第一个s后分,但是不显示分割字符s
v5=test.split('s',2)        # 以目标's'分割,找到2个s后停止分割,且不显示分割字符s
print(v1)
print(v2)
print(v3)
print(v4)
print(v5)

4858.com 277

特例:test.splitlines() 
表示根据换行符‘\n’分割      test.splitlines(True) 则彰显换行符‘\n’,
test.splitlines(False),则不突显换行符‘\n’。

7、

test='alexalexalex'
v=test.replace('al','bbb',2)        # 替换功能
print(v)

4858.com 278

 

 

特种用法:

1、

test='alex'
v=test[2]           # 据 索引 或 下标 获取字符串中的某个字符
print(v)
v2=test[0:2]        # 索引范围 左开右闭,顾头不顾尾
print(v2)
v3=len(test)        # 判断当前字符串有多少字符组成
print(v3)

4858.com 279

2、for

test='苟陇辉苟'
index=0
while index<len(test):
    v=test[index]
    print(v)
    index+=1
print('====')

4858.com 280

使用for语句时:

test='苟陇辉苟'     # for 循环格式   for 变量名 in 字符串:
for v in test:      #                    变量名
    print(v)

4858.com 281     一个一个输出

 

字符串一旦创建,不可修改;

假如修改只怕拼接,都会导致重复生成字符串;

补充:

range的用法   
支持创造两次三番的数字,v=range(0,100,5)步长为5

                 v=’alexalexalex’

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

 

陶冶题:将用户输入的文字及其相应的目录打印出来。

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

4858.com 282

 

 三、列表list

list
为类,li为经过list类创设的靶子,列表里每种因素通过, 隔开,中括号
括起来;可以修改,删除

方法

1、

 

li = [1,12,9,'age',['苟陇辉',[19,10],'你'],'alex',True]

 

li = [1,12,9,'age',['苟陇辉',[19,10],'你'],'alex',True]
print(li[3])            #
print(li[3:5])
li[1] = 120
print(li)
li[1] = [11,22,33,44]
print(li)
li[2:4] = [120,90]
print(li)
del li[1]
print(li)
del li[2:6]
print(li)           # 可通过索引、切片 取值,删除其中的元素

4858.com 283

 

无异于支撑for循环,while 循环

2、in 操作

v = 12 in li

print(v)        True

 

3、

li = [1,12,9,'age',['苟陇辉',['19','10'],'你'],'alex',True]
v = li[4][1][0][1]      # 索引取值一直往里找
print(v)

结果为9
4、
(1)

s = 'asdfghkl'
list(s)             # 转化功能   字符串转化为列表,内部使用的for循环,注意: 数字不可被转化,不可使用for循环
print(list(s))

4858.com 284

(2)、列表转化字符串

①:列表中既有数字,又有字符串是 须求本人写一个for循环一个一个拍卖:

li=[1,2,3,’alex]

s=”

for item in li

  s=s+str(item)

print(s)

② 唯有字符串

li=[‘123′,’alex’]

v=”.join(li)

print(v)

貌似方法:

1、

li = ['11','22','33','44']
li.append(5)            # 直接在原值后面追加一个
print(li)
li.append([99,'苟陇辉'])      # 只将一个整体以列表的形式加进去
print(li)
li.extend([99,'苟陇辉'])       # 将每一个元素都加进去
print(li)

4858.com 285

2、

li = ['11', '22', '33', '44']
v = li.copy()                       # 浅拷贝   
print(v)

4858.com 286

3、

li = ['11', '22', '33', '44','22']
v = li.count('22')                  #  计算‘22 ’出现的次数
print(v)

4858.com 287

4、

li = [11,22,33,22,44]
v = li.index(22)                # 寻找当前元素的索引,找到第一个之后就不在找了
print(v)
v = li.index(22,2,4)            # 可加起始位置
print(v)
v = li.insert(0,99)             # 在指定位置0, 插入指定元素99
print(v)

5、

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

4858.com 288

6、删除

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)

4858.com 289

 四、元祖  tuple

类:元祖   依照元祖类成立的靶子 tu ;     
 #  元祖是对列表的二次加工; 
小括号括起来,最前面加一个逗号“,”;

注:元祖(顶尖成分)不可被改动,无法被扩张可能去除; 
 有序的;

tu =
(111,’alex’,(,),[()],True,33,44,)

 常用艺术:

1、索引取值:v = tu[0]

2、切片取值:v = tu[0:2]

3、支持for循环

4、互相转换:s li tu

v = tuple(s)   v = tuple(li)

v = list(tu)     v = ‘_’.join(tu)(
唯有字符串时)

诚如方法:

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

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

 

五、字典 dict

对象   info = {‘k1′:’v1′,’k2′:’v2’}

info = {‘k1’:18,

           ‘k2’:true

         
 ‘k3’:[11,22,33,{‘kk1′:’vv1′,’kk2′:’vv2′},’kk3’:(11,22,)]

           ‘k4’:(11,22,33)}

只顾: value  然则任意值

             key    列表,字典,不可为key
;bool值  True  默许=1   False  默许=0,假诺重复是  则不显得

1、字典是无序的

2、取值:据K取值,即据索引取到指定元素,但不可利用切片(因为字典是无序的)。

3、删除:据K删除      del info
[‘k3’][‘kk1’]

4、支持for循环 

for item in info         ==       for item
in into.keys      私行认同循环‘k’

  print(item)   

for item in info.values       
循环‘values’

  print(item)

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

  print(k,v)

5.v = dic.get(‘k1′,’111’)   
依据k获取值,key不存在时,可以可指定输入结果 111 
 不指定值时,暗许结果为none

   print(v)

6 、v = dic.pop(‘k1’,90)   
 找不到K值时,不报错,可指定 90  结果   
注意:不写k时,暗中认同删除最终一个

      print(dic,v)   其中v 为除去的值 
 

      dic.popitem  随机删除

7、v = dic.setdefault(‘k’,123)   

 
 设置值,若key以存在,则不设置,获取当前k对应的值;
不存在时,设置并拿走当前K对应的值

8、dic.uptade({‘k1′:’1234′,’k3′:’3333’}) 
  更新字典,若K以存在,则更新其V,若K不存在,加一个进去。

六、BOOL值

注意:转换为bool值  :  bool()

     假: 
空字典,空列表,空元祖,空字符串,0

任何均为真。

   总结:

可变:列表,字典

不可变:字符串,数字,元祖     
            验证措施:name = ‘alex’  id(name)  可查看其储存ID

 

走访顺序:①:直接访问:数字

                 
②:顺序访问(即索引):字符串、列表、元祖

                 
③:映射:字典

仓储元素个数:

                     
容器类型:列表、元祖、字典

                     
 原子: 数字、字符串

七、集合:   s = {,,,}

概念:①:差距因素构成

           ②:无序

         
 ③:集合中的成分必须是不足变类型:数字、字符串、元祖

方法:

# 集合:
# s = set('hello')            # 定义一个集合
# print(s)

# s = {1,2,3,4,5,'6'}
# s.add('2')                  # 添加一个元素
# print(s)

# s = {1,2,3,4,5,'6'}
# s.clear()                   # 清空列表
# print(s)

# s = {1,2,3,4,5,'6'}
# s1 = s.copy()                 # 复制
# print(s1)

# s = {1,2,3,4,5,'6'}
# s.pop()                         # 随机删
# print(s)

# s = {1,2,3,4,5,'6'}
# s.remove('6')               # 指定元素删除,找不到时报错
# s1 = s.discard('6')         # 指定元素删除,找不到时不报错

# v = ['aaa','bbb','ccc']
# v1 = ['aaa','bbb','eee']
# s = set(v)
# s1 = set(v1)
# print(s,s1)
# print(s.intersection(s1))   # 交集
# print(s&s1)                 # 交集
#
# print(s.union(s1))          # 并集
# print(s|s1)                 # 并集
#
# print(s.difference(s1))     # 差集
# print(s1.difference(s))     # 差集
#
# print(s.symmetric_difference(s1))   # 交叉补集
# print(s^s1)                         # 交叉补集
#
# s.difference_update(s1)             # 差集之后 将得到的集合赋值给给s (即更新)
# print(s)

# s1 = {1, 2}
# s2 = {1, 2, 3, 4}
# print(s1.issubset(s2))   #    结果为 True   s1是s2的子集
# print(s2.issuperset(s1))  #   True   s2是s1的父集
# s1.update(s2)    # 更新多个值
# s1.add(5)  # 更新一个值
# s1.union(s2)     # 不更新
# print(s1)

# s = set( )        # 定义可变的集合
# s = frozenset()   # 定义不可变的集合

# names = ['alex','glh','alex','wc']          #  简单去重
# s = set(names)
# print(s)
# names = list(s)

八、字符串格式化

 

字符串格式化:
# 一:百分号方式
#  %s 均可接收    %d 只能接收数字类型   %f 浮点数(小数)
# msg = 'i am %s my hobby is %s' %('glh','alex')     # %.2s代表截取字符串的长度为2
# print(msg)

# tpl = 'percent%.2f' %(99.895652)        #2代表保留2位小数
# print(tpl)
# tpl = 'percent%.2f %%'%(99.895652)      # 打印百分比
# print(tpl)
# 
# tpl = 'i am %(pp).2f' %{'pp': 123.456}   #  后边为字典
# print(tpl)
# 
# msg = 'i am %(name)+60s %(age)d'%{'name': 'glh','age': 23}      # +号表示右对齐并补齐60位
# print(msg)
# msg = 'i am \033[46;1m%(name)+60s\033[0m my hobby is alex ' %{'name': 'glh'}        # 加颜色
# print(msg)
# 
# print('root','x','x','o',sep=':')  # 分别得到结果 后拼接成一条记录    结果为  root:x:x:o
# 
# 二 format 字符串格式化

# tpl = 'i am {},age{},{}'.format('glh','23','alex')
# print(tpl)
# tpl = 'i am {2},age{1},{0}'.format('glh','23',['alex',23])      # 相当于按照后面后面元祖索引取值
# print(tpl)

# #  .format('seven',18) == .format(*['seven',18])
# #  .format('seven',18) == .format(**{'seven',18})

# tpl = 'numbers: {:b},{:o},{:d},{:x},{:X},{:%}'.format(15,15,15,15,15,15.89632)
# print(tpl)
# # 结果为numbers: 1111,17,15,f,F,1589.632000%   上述分别代表打印二进制 八进制 十进制 十六进制小写 十六进制大写 转换为百分数,默认保留6位

         

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

        

 

 

 

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有