第一篇（下）python基础（二）

数字类型

 1 # 一：int类型
 2 # 1、作用：
 3 # 2、定义：
 4 # age = 10 # age=int(10)
 5 
 6 # 名字(参数)
 7 # print('hello','world')
 8 
 9 # x=int(10)
10 # name=input('xxx')
11 # res=print('xxx') # 没有产品
12 # print(res)
13 
14 # 2、类型转换
15 # 2.1 纯数字的字符串转成int
16 # res=int('100111')
17 # print(res,type(res))
18 
19 # 2.2（了解）
20 # 2.2.1 十进制转成其他进制
21 # 10进制 -> 二进制
22 # 11 - > 1011
23 # 1011-> 8+2+1
24 # print(bin(11)) # 0b1011
25 
26 # 10进制 -> 八进制
27 # print(oct(11)) # 0o13
28 
29 # 10进制 -> 十六进制
30 # print(hex(11)) # 0xb
31 # print(hex(123)) # 0xb
32 
33 # 2.2.2 其他制转成其十进制
34 # 二进制->10进制
35 # print(int('0b1011',2)) # 11
36 
37 # 二进制->8进制
38 # print(int('0o13',8)) # 11
39 
40 # 二进制->16进制
41 # print(int('0xb',16)) # 11
42 
43 # 3、使用
44 
45 # 二：float类型
46 # 1、作用
47 # 2、定义
48 # salary=3.1 # salary=float(3.1)
49 
50 # 3、类型转换
51 # res=float("3.1")
52 # print(res,type(res))
53 
54 # 4、使用
55 # int与float没有需要掌握的内置方法
56 # 他们的使用就是数学运算+比较运算

数字类型（进制转化）

字符串类型

# 1、作用
# 2、定义
# msg='hello' # msg=str('msg')
# print(type(msg))

# 3、类型转换
# str可以把任意其他类型都转成字符串
# res=str({'a':1})
# print(res,type(res))

# 4、使用：内置方法
# 4.1 优先掌握
# 4.1.1、按索引取值(正向取+反向取) ：只能取
msg='hello world'
# 正向取
# print(msg[0])
# print(msg[5])
# 反向取
# print(msg[-1])

# 只能取
# msg[0]='H'


# 4.1.2、切片:索引的拓展应用，从一个大字符串中拷贝出一个子字符串
msg='hello world'
# 顾头不顾尾
# res=msg[0:5] #x
# print(res)
# print(msg)

# 步长
# res=msg[0:5:2] # 0 2 4
# print(res) # hlo

# 反向步长(了解)
# res=msg[5:0:-1]
# print(res) #" olle"

msg='hello world'
# res=msg[:] # res=msg[0:11]
# print(res)

# res=msg[::-1] # 把字符串倒过来
# print(res)

# 4.1.3、长度len
# msg='hello world'
# print(len(msg))

# 4.1.4、成员运算in和not in
# 判断一个子字符串是否存在于一个大字符串中
# print("alex" in "alex is sb")
# print("alex" not in "alex is sb")
# print(not "alex" in "alex is sb") # 不推荐使用

# 4.1.5、移除字符串左右两侧的符号strip
# 默认去掉的空格
# msg='      egon      '
# res=msg.strip()
# print(msg) # 不会改变原值
# print(res) # 是产生了新值

# 默认去掉的空格
# msg='****egon****'
# print(msg.strip('*'))

# 了解：strip只取两边，不去中间
# msg='****e*****gon****'
# print(msg.strip('*'))

# msg='**/*=-**egon**-=()**'
# print(msg.strip('*/-=()'))

# 应用
# inp_user=input('your name>>: ').strip() # inp_user=" egon"
# inp_pwd=input('your password>>: ').strip()
# if inp_user == 'egon' and inp_pwd == '123':
#     print('登录成功')
# else:
#     print('账号密码错误')


# 4.1.6、切分split：把一个字符串按照某种分隔符进行切分，得到一个列表
# # 默认分隔符是空格
# info='egon 18 male'
# res=info.split()
# print(res)

# # 指定分隔符
# info='egon:18:male'
# res=info.split(':')
# print(res)

# 指定分隔次数(了解)
# info='egon:18:male'
# res=info.split(':',1)
# print(res)

# 4.1.7、循环
# info='egon:18:male'
# for x in info:
#     print(x)


# 4.2 需要掌握
#4.2.1、strip,lstrip,rstrip
# msg='***egon****'
# print(msg.strip('*'))
# print(msg.lstrip('*'))
# print(msg.rstrip('*'))

#4.2.2、lower,upper
# msg='AbbbCCCC'
# print(msg.lower())
# print(msg.upper())

#4.2.3、startswith,endswith
# print("alex is sb".startswith("alex"))
# print("alex is sb".endswith('sb'))

#4.2.4、format

#4.2.5、split,rsplit:将字符串切成列表
# info="egon:18:male"
# print(info.split(':',1)) # ["egon","18:male"]
# print(info.rsplit(':',1)) # ["egon:18","male"]

#4.2.6、join: 把列表拼接成字符串
# l=['egon', '18', 'male']
# res=l[0]+":"+l[1]+":"+l[2]
# res=":".join(l) # 按照某个分隔符号，把元素全为字符串的列表拼接成一个大字符串
# print(res)

# l=[1,"2",'aaa']
# ":".join(l)

#4.2.7、replace
# msg="you can you up no can no bb"
# print(msg.replace("you","YOU",))
# print(msg.replace("you","YOU",1))

#4.2.8、isdigit
# 判断字符串是否由纯数字组成
# print('123'.isdigit())
# print('12.3'.isdigit())

# age=input('请输入你的年龄：').strip()
# if age.isdigit():
#     age=int(age) # int("abbab")
#     if age > 18:
#         print('猜大了')
#     elif age < 18:
#         print('猜小了')
#     else:
#         print('才最了')
# else:
#     print('必须输入数字，傻子')

# 4.3了解
#4.3.1、find,rfind,index,rindex,count
msg='hello egon hahaha'
# 找到返回起始索引
# print(msg.find('e')) # 返回要查找的字符串在大字符串中的起始索引
# print(msg.find('egon'))
# print(msg.index('e'))
# print(msg.index('egon'))
# 找不到
# print(msg.find('xxx')) # 返回-1，代表找不到
# print(msg.index('xxx')) # 抛出异常

# msg='hello egon hahaha egon、 egon'
# print(msg.count('egon'))

#4.3.2、center,ljust,rjust,zfill
# print('egon'.center(50,'*'))
# print('egon'.ljust(50,'*'))
# print('egon'.rjust(50,'*'))
# print('egon'.zfill(10))

#4.3.3、expandtabs
# msg='hello\tworld'
# print(msg.expandtabs(2)) # 设置制表符代表的空格数为2

#4.3.4、captalize,swapcase,title
# print("hello world egon".capitalize())
# print("Hello WorLd EGon".swapcase())
# print("hello world egon".title())

#4.3.5、is数字系列
#4.3.6、is其他
# print('abc'.islower())
# print('ABC'.isupper())
# print('Hello World'.istitle())
# print('123123aadsf'.isalnum()) # 字符串由字母或数字组成结果为True
# print('ad'.isalpha()) # 字符串由由字母组成结果为True
# print('     '.isspace()) # 字符串由空格组成结果为True
# print('print'.isidentifier())
# print('age_of_egon'.isidentifier())
# print('1age_of_egon'.isidentifier())


num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字

# isdigit只能识别：num1、num2
# print(num1.isdigit()) # True
# print(num2.isdigit()) # True
# print(num3.isdigit()) # False
# print(num4.isdigit()) # False



# isnumberic可以识别：num2、num3、num4
# print(num2.isnumeric()) # True
# print(num3.isnumeric()) # True
# print(num4.isnumeric()) # True

# isdecimal只能识别：num2
print(num2.isdecimal()) # True
print(num3.isdecimal()) # False
print(num4.isdecimal()) # False

字符串类型

for循环

  1 '''
  2 1、什么是for循环
  3     循环就是重复做某件事，for循环是python提供第二种循环机制
  4 
  5 2、为何要有for循环
  6     理论上for循环能做的事情，while循环都可以做
  7     之所以要有for循环，是因为for循环在循环取值（遍历取值）比while循环更简洁
  8 
  9 3、如何用for循环
 10 语法：
 11 for 变量名 in 可迭代对象:# 可迭代对象可以是：列表、字典、字符串、元组、集合
 12     代码1
 13     代码2
 14     代码3
 15     ...
 16 '''
 17 # 一：for基本使用之循环取值
 18 # 案例1：列表循环取值
 19 # 简单版
 20 # l = ['alex_dsb', 'lxx_dsb', 'egon_nb']
 21 # for x in l:  # x='lxx_dsb'
 22 #     print(x)
 23 
 24 # 复杂版：
 25 # l = ['alex_dsb', 'lxx_dsb', 'egon_nb']
 26 # i=0
 27 # while i < 3:
 28 #     print(l[i])
 29 #     i+=1
 30 
 31 
 32 # 案例2：字典循环取值
 33 # 简单版
 34 # dic={'k1':111,'k2':2222,'k3':333}
 35 # for k in dic:
 36 #     print(k,dic[k])
 37 
 38 # 复杂版：while循环可以遍历字典，太麻烦了
 39 
 40 # 案例3：字符串循环取值
 41 # 简单版
 42 # msg="you can you up,no can no bb"
 43 # for x in msg:
 44 #     print(x)
 45 
 46 # 复杂版：while循环可以遍历字典，太麻烦了
 47 
 48 
 49 # 二：总结for循环与while循环的异同
 50 # 1、相同之处：都是循环，for循环可以干的事，while循环也可以干
 51 # 2、不同之处：
 52 #           while循环称之为条件循环，循环次数取决于条件何时变为假
 53 #           for循环称之为"取值循环"，循环次数取决in后包含的值的个数
 54 # for x in [1,2,3]:
 55 #     print('===>')
 56 #     print('8888')
 57 
 58 
 59 # 三：for循环控制循环次数：range()
 60 # in后直接放一个数据类型来控制循环次数有局限性：
 61 #                 当循环次数过多时，数据类型包含值的格式需要伴随着增加
 62 # for x in 'a c':
 63 #     inp_name=input('please input your name:   ')
 64 #     inp_pwd=input('please input your password:   ')
 65 #
 66 
 67 # range功能介绍
 68 '''
 69 >>> range(10)
 70 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 71 >>> 
 72 >>> range(1,9) # 1...8
 73 [1, 2, 3, 4, 5, 6, 7, 8]
 74 >>> 
 75 >>> range(1,9,1) # 1 2 3 4 5 6 7 8 
 76 [1, 2, 3, 4, 5, 6, 7, 8]
 77 >>> range(1,9,2) # 1 3 5 7 
 78 [1, 3, 5, 7]
 79 '''
 80 # for i in range(30):
 81 #     print('===>')
 82 
 83 
 84 # for+break: 同while循环一样
 85 # for+else：同while循环一样
 86 # username='egon'
 87 # password='123'
 88 # for i in range(3):
 89 #     inp_name = input('请输入您的账号：')
 90 #     inp_pwd = input('请输入您的密码：')
 91 #
 92 #     if inp_name == username and inp_pwd == password:
 93 #         print('登录成功')
 94 #         break
 95 # else:
 96 #     print('输错账号密码次数过多')
 97 
 98 
 99 # 四：range补充知识（了解）
100 # 1、for搭配range，可以按照索引取值，但是麻烦，所以不推荐
101 # l=['aaa','bbb','ccc'] # len(l)
102 # for i in range(len(l)):
103 #     print(i,l[i])
104 #
105 # for x in l:
106 #     print(l)
107 # 2、range()在python3里得到的是一只"会下蛋的老母鸡"
108 
109 
110 # 五：for+continue
111 # for i in range(6):  # 0 1 2 3 4 5
112 #     if i == 4:
113 #         continue
114 #     print(i)
115 
116 # 六：for循环嵌套:外层循环循环一次，内层循环需要完整的循环完毕
117 # for i in range(3):
118 #     print('外层循环-->', i)
119 #     for j in range(5):
120 #         print('内层-->', j)
121 
122 # 补充：终止for循环只有break一种方案
123 
124 # print('hello %s' % 'egon')
125 # 1、print之逗号的使用
126 # print('hello','world','egon')
127 # 2、换行符
128 # print('hello\n')
129 # print('world')
130 # 3、print值end参数的使用
131 # print('hello\n',end='')
132 # print('word')
133 print('hello',end='*')
134 print('world',end='*')

for循环

列表

  1 # 1、作用：按位置存放多个值
  2 # 2、定义
  3 # l=[1,1.2,'a'] # l=list([1,1.2,'a'])
  4 # print(type(l))
  5 
  6 # 3、类型转换: 但凡能够被for循环遍历的类型都可以当做参数传给list()转成列表
  7 # res=list('hello')
  8 # print(res)
  9 #
 10 # res=list({'k1':111,'k2':222,'k3':3333})
 11 # print(res)
 12 
 13 
 14 # 4、内置方法
 15 # 优先掌握的操作：
 16 # 1、按索引存取值(正向存取+反向存取)：即可以取也可以改
 17 # l=[111,'egon','hello']
 18 # 正向取
 19 # print(l[0])
 20 # 反向取
 21 # print(l[-1])
 22 # 可以取也可以改：索引存在则修改对应的值
 23 # l[0]=222
 24 # print(l)
 25 
 26 # 无论是取值操作还是赋值操作：索引不存在则报错
 27 # l[3]=333
 28 
 29 
 30 # 2、切片(顾头不顾尾，步长)
 31 l = [111, 'egon', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]
 32 # print(l[0:3])
 33 # print(l[0:5:2]) # 0 2 4
 34 
 35 # print(l[0:len(l)])
 36 # print(l[:])
 37 # new_l=l[:] # 切片等同于拷贝行为，而且相当于浅copy
 38 # print(id(l))
 39 # print(id(new_l))
 40 
 41 # l[-1][0]=1111111
 42 # print(l)
 43 # print(new_l)
 44 
 45 # print(l[::-1])
 46 
 47 # msg1='hello:egon:<>:18[]==123'
 48 # msg2=msg1[:]
 49 # print(msg1,id(msg1))
 50 # print(msg2,id(msg2))
 51 # 3、长度
 52 # print(len([1, 2, 3]))
 53 # 4、成员运算in和not in
 54 # print('aaa' in ['aaa', 1, 2])
 55 # print(1 in ['aaa', 1, 2])
 56 # 5、往列表中添加值
 57 # 5.1 追加
 58 # l=[111,'egon','hello']
 59 # l.append(3333)
 60 # l.append(4444)
 61 # print(l)
 62 
 63 # 5.2、插入值
 64 # l=[111,'egon','hello']
 65 # l.insert(0,'alex')
 66 # print(l)
 67 
 68 # 5.3、extend添加值
 69 # new_l=[1,2,3]
 70 # l=[111,'egon','hello']
 71 # l.append(new_l)
 72 # print(l)
 73 
 74 # 代码实现
 75 # for item in new_l:
 76 #     l.append(item)
 77 # print(l)
 78 
 79 # extend实现了上述代码
 80 # l.extend(new_l)
 81 # l.extend('abc')
 82 # print(l)
 83 
 84 
 85 # 7、删除
 86 # 方式一：通用的删除方法，只是单纯的删除、没有返回值
 87 # l = [111, 'egon', 'hello']
 88 # del l[1]
 89 # x =del l[1] # 抛出异常，不支持赋值语法
 90 # print(l)
 91 
 92 # 方式二：l.pop()根据索引删除，会返回删除的值
 93 # l = [111, 'egon', 'hello']
 94 # l.pop() # 不指定索引默认删除最后一个
 95 # l.pop()
 96 # print(l)
 97 
 98 # res=l.pop(1)
 99 # print(l)
100 
101 # print(res)
102 
103 # 方式三：l.remove()根据元素删除，返回None
104 # l = [111, 'egon', [1,2,3],'hello']
105 # l.remove([1,2,3])
106 # print(l)
107 # res=l.remove('egon')
108 # print(res) # None
109 
110 
111 # 8、循环
112 # l=[1,'aaa','bbb']
113 # for x in l:
114 #     l.pop(1)
115 #     print(x)
116 
117 # 需要掌握操作
118 # l = [1, 'aaa', 'bbb','aaa','aaa']
119 # 1、l.count()
120 # print(l.count('aaa'))
121 
122 # 2、l.index()
123 # print(l.index('aaa'))
124 # print(l.index('aaaaaaaaa')) # 找不到报错
125 
126 # 3、l.clear()
127 # l.clear()
128 # print(l)
129 
130 # 4、l.reverse():不是排序，就是将列表倒过来
131 # l = [1, 'egon','alex','lxx']
132 # l.reverse()
133 # print(l)
134 
135 # 5、l.sort(): 列表内元素必须是同种类型才可以排序
136 # l=[11,-3,9,2,3.1]
137 # l.sort() # 默认从小到大排，称之为升序
138 # l.sort(reverse=True) # 从大到小排，设置为降序
139 # print(l)
140 
141 # l=[11,'a',12]
142 # l.sort()
143 
144 # l=['c','e','a']
145 # l.sort()
146 # print(l)
147 
148 # 排序：列表内为字典，按字典相应字段排序
149 # source_list=[{"count": 91, "source": "stock.10jqka.com.cn"},{"count": 77, "source": "finance.ifeng.com"}]
150 # print("排序前的数据：\n",source_list)
151 # source_list.sort(key=lambda source: source["count"],reverse=True) # 按照count进行排序(降序)
152 # print("排好序后新数据：\n{}".format(count_source_list))
153 
154 # 了解：字符串可以比大小，按照对应的位置的字符依次pk
155 # 字符串的大小是按照ASCI码表的先后顺序加以区别，表中排在后面的字符大于前面的
156 # print('a'>'b')
157 # print('abz'>'abcdefg')
158 
159 # 了解：列表也可以比大小,原理同字符串一样,但是对应位置的元素必须是同种类型
160 # l1=[1,'abc','zaa']
161 # l2=[1,'abc','zb']
162 #
163 # print(l1 < l2)
164 
165 
166 # 补充
167 # 1、队列：FIFO,先进先出
168 # l=[]
169 # # 入队操作
170 # l.append('first')
171 # l.append('second')
172 # l.append('third')
173 #
174 # print(l)
175 # # 出队操作
176 # print(l.pop(0))
177 # print(l.pop(0))
178 # print(l.pop(0))
179 
180 # 2、堆栈：LIFO,后进先出
181 l=[]
182 # 入栈操作
183 l.append('first')
184 l.append('second')
185 l.append('third')
186 
187 print(l)
188 # 出队操作
189 print(l.pop())
190 print(l.pop())
191 print(l.pop())

list

元组

 1 # 元组就是"一个不可变的列表"
 2 #1、作用：按照索引/位置存放多个值，只用于读不用于改
 3 
 4 #2、定义:（）内用逗号分隔开多个任意类型的元素
 5 # t=(1,1.3,'aa') # t=tuple((1,1.3,'aa'))
 6 # print(t,type(t))
 7 
 8 
 9 # x=(10) # 单独一个括号代表包含的意思
10 # print(x,type(x))
11 
12 # t=(10,) # 如果元组中只有一个元素，必须加逗号
13 # print(t,type(t))
14 
15 # t=(1,1.3,'aa') # t=(0->值1的内存地址,1->值1.3的内存地址,2->值'aaa'的内存地址，)
16 # t[0]=11111
17 
18 # t=(1,[11,22]) # t=(0->值1的内存地址,1->值[1,2]的内存地址，)
19 # print(id(t[0]),id(t[1]))
20 # # t[0]=111111111 # 不能改
21 # # t[1]=222222222 # 不能改
22 #
23 # t[1][0]=11111111111111111
24 # # print(t)
25 # print(id(t[0]),id(t[1]))
26 
27 
28 #3、类型转换
29 # print(tuple('hello'))
30 # print(tuple([1,2,3]))
31 # print(tuple({'a1':111,'a2':333}))
32 
33 #4、内置方法
34 #优先掌握的操作：
35 #1、按索引取值(正向取+反向取)：只能取
36 # t=('aa','bbb','cc')
37 # print(t[0])
38 # print(t[-1])
39 
40 #2、切片(顾头不顾尾，步长)
41 # t=('aa','bbb','cc','dd','eee')
42 # print(t[0:3])
43 # print(t[::-1])
44 
45 #3、长度
46 # t=('aa','bbb','cc','dd','eee')
47 # print(len(t))
48 #4、成员运算in和not in
49 # print('aa' in t)
50 
51 #5、循环
52 # for x in t:
53 #     print(x)
54 
55 #6、
56 t=(2,3,111,111,111,111)
57 # print(t.index(111))
58 # print(t.index(1111111111))
59 
60 print(t.count(111))

tuple

字典

-- 字典排序
data ={'元気森林旗舰店': 51640.0, '一包生活旗舰店': 22108.0, '一只小猪零食铺': 24747.0}
# 排序 （升序）
data = dict(sorted(data.items(), key=lambda item: item[1])[-10:])
print(data) # {'一包生活旗舰店': 22108.0, '一只小猪零食铺': 24747.0, '元気森林旗舰店': 51640.0}

  1 #1、作用
  2 
  3 #2、定义：{}内用逗号分隔开多个key：value，其中value可以使任意类型，但是
  4 #                                   key必须是不可变类型,且不能重复
  5 # 造字典的方式一：
  6 # d={'k1':111,(1,2,3):222} # d=dict(...)
  7 # print(d['k1'])
  8 # print(d[(1,2,3)])
  9 # print(type(d))
 10 
 11 # d={} # 默认定义出来的是空字典
 12 # print(d,type(d))
 13 
 14 # 造字典的方式二：
 15 # d=dict(x=1,y=2,z=3)
 16 # print(d,type(d))
 17 
 18 
 19 #3、数据类型转换
 20 # info=[
 21 #     ['name','egon'],
 22 #     ('age',18),
 23 #     ['gender','male']
 24 # ]
 25 # # d={}
 26 # # for k,v in info: # k,v=['name','egon'],
 27 # #     d[k]=v
 28 # # print(d)
 29 #
 30 # 造字典的方式三：
 31 # res=dict(info) # 一行代码搞定上述for循环的工作
 32 # print(res)
 33 
 34 
 35 # 造字典的方式四:快速初始化一个字典
 36 # keys=['name','age','gender']
 37 # # d={}
 38 # # for k in keys:
 39 # #     d[k]=None
 40 # # print(d)
 41 # d={}.fromkeys(keys,None) # 一行代码搞定上述for循环的工作
 42 # print(d)
 43 
 44 #4、内置方法
 45 #优先掌握的操作：
 46 #1、按key存取值：可存可取
 47 # d={'k1':111}
 48 # 针对赋值操作：key存在，则修改
 49 # d['k1']=222
 50 # 针对赋值操作：key不存在，则创建新值
 51 # d['k2']=3333
 52 # print(d)
 53 
 54 #2、长度len
 55 # d={'k1':111,'k2':2222,'k1':3333,'k1':4444}
 56 # print(d)
 57 # print(len(d))
 58 
 59 
 60 #3、成员运算in和not in:根据key
 61 # d={'k1':111,'k2':2222}
 62 # print('k1' in d)
 63 # print(111 in d)
 64 
 65 #4、删除
 66 d={'k1':111,'k2':2222}
 67 # 4.1 通用删除
 68 # del d['k1']
 69 # print(d)
 70 
 71 # 4.2 pop删除：根据key删除元素，返回删除key对应的那个value值
 72 # res=d.pop('k2')
 73 # print(d)
 74 # print(res)
 75 
 76 # 4.3 popitem删除：随机删除，返回元组(删除的key,删除的value)
 77 # res=d.popitem()
 78 # print(d)
 79 # print(res)
 80 
 81 #5、键keys()，值values()，键值对items()  =>在python3中得到的是老母鸡
 82 d={'k1':111,'k2':2222}
 83 '''
 84 在python2中
 85 >>> d={'k1':111,'k2':2222}
 86 >>> 
 87 >>> d.keys()#6、循环
 88 ['k2', 'k1']
 89 >>> d.values()
 90 [2222, 111]
 91 >>> d.items()
 92 [('k2', 2222), ('k1', 111)]
 93 >>> dict(d.items())
 94 {'k2': 2222, 'k1': 111}
 95 >>>
 96 '''  
 97 
 98 #6、for循环
 99 # for k in d.keys():
100 #     print(k)
101 #
102 # for k in d:
103 #     print(k)
104 
105 # for v in d.values():
106 #     print(v)
107 
108 # for k,v in d.items():
109 #     print(k,v)
110 
111 
112 # print(list(d.keys()))
113 # print(list(d.values()))
114 # print(list(d.items()))
115 
116 
117 #需要掌握的内置方法
118 d={'k1':111}
119 #1、d.clear()
120 
121 #2、d.update()
122 # d.update({'k2':222,'k3':333,'k1':111111111111111})
123 # print(d)
124 
125 #3、d.get() ：根据key取值，容错性好
126 # print(d['k2'])  # key不存在则报错
127 
128 # print(d.get('k1')) # 111
129 # print(d.get('k2')) # key不存在不报错，返回None
130 
131 #4、d.setdefault()
132 # info={}
133 # if 'name' in info:
134 #     ... # 等同于pass
135 # else:
136 #     info['name']='egon'
137 # print(info)
138 
139 # 4.1 如果key有则不添加,返回字典中key对应的值
140 info={'name':'egon'}
141 res=info.setdefault('name','egon')
142 # print(info)
143 
144 print(res)
145 
146 # 4.2 如果key没有则添加，返回字典中key对应的值
147 info={}
148 res=info.setdefault('name','egon')
149 # print(info)
150 print(res)

dict

集合

  1 # 1、作用
  2 # 1.1 关系运算
  3 # friends1 = ["zero","kevin","jason","egon"]
  4 # friends2 = ["Jy","ricky","jason","egon"]
  5 #
  6 # l=[]
  7 # for x in friends1:
  8 #     if x in friends2:
  9 #         l.append(x)
 10 # print(l)
 11 
 12 
 13 # 1.2、去重
 14 
 15 
 16 # 2、定义: 在{}内用逗号分隔开多个元素，多个元素满足以下三个条件
 17 #            1. 集合内元素必须为不可变类型
 18 #            2. 集合内元素无序
 19 #            3. 集合内元素没有重复
 20 
 21 # s={1,2} # s=set({1,2})
 22 
 23 # s={1,[1,2]} # 集合内元素必须为不可变类型
 24 # s={1,'a','z','b',4,7} # 集合内元素无序
 25 # s={1,1,1,1,1,1,'a','b'} # 集合内元素没有重复
 26 # print(s)
 27 
 28 # 了解
 29 # s={} # 默认是空字典
 30 # print(type(s))
 31 # 定义空集合
 32 # s=set()
 33 # print(s,type(s))
 34 
 35 # 3、类型转换
 36 # set({1,2,3})
 37 # res=set('hellolllll')
 38 # print(res)
 39 
 40 # print(set([1,1,1,1,1,1]))
 41 # print(set([1,1,1,1,1,1,[11,222]]) # 报错
 42 
 43 # print(set({'k1':1,'k2':2}))
 44 
 45 # 4、内置方法
 46 # =========================关系运算符=========================
 47 friends1 = {"zero","kevin","jason","egon"}
 48 friends2 = {"Jy","ricky","jason","egon"}
 49 
 50 # 4.1 取交集：两者共同的好友
 51 # res=friends1 & friends2
 52 # print(res)
 53 # print(friends1.intersection(friends2))
 54 # 4.2 取并集/合集：两者所有的好友
 55 # print(friends1 | friends2)
 56 # print(friends1.union(friends2))
 57 
 58 # 4.3 取差集：取friends1独有的好友
 59 # print(friends1 - friends2)
 60 # print(friends1.difference(friends2))
 61 
 62 # 取friends2独有的好友
 63 # print(friends2 - friends1)
 64 # print(friends2.difference(friends1))
 65 
 66 # 4.4 对称差集: 求两个用户独有的好友们（即去掉共有的好友）
 67 # print(friends1 ^ friends2)
 68 # print(friends1.symmetric_difference(friends2))
 69 
 70 # 4.5 父子集：包含的关系
 71 # s1={1,2,3}
 72 # s2={1,2,4}
 73 # 不存在包含关系，下面比较均为False
 74 # print(s1 > s2)
 75 # print(s1 < s2)
 76 
 77 # s1={1,2,3}
 78 # s2={1,2}
 79 # print(s1 > s2) # 当s1大于或等于s2时，才能说是s1是s2他爹
 80 # print(s1.issuperset(s2))
 81 # print(s2.issubset(s1)) # s2 < s2  =>True
 82 
 83 # s1={1,2,3}
 84 # s2={1,2,3}
 85 # print(s1 == s2) # s1与s2互为父子
 86 # print(s1.issuperset(s2))
 87 # print(s2.issuperset(s1))
 88 
 89 
 90 # =========================去重=========================
 91 # 1、只能针对不可变类型去重
 92 # print(set([1,1,1,1,2]))
 93 
 94 # 2、无法保证原来的顺序
 95 # l=[1,'a','b','z',1,1,1,2]
 96 # l=list(set(l))
 97 # print(l)
 98 
 99 
100 l=[
101     {'name':'lili','age':18,'sex':'male'},
102     {'name':'jack','age':73,'sex':'male'},
103     {'name':'tom','age':20,'sex':'female'},
104     {'name':'lili','age':18,'sex':'male'},
105     {'name':'lili','age':18,'sex':'male'},
106 ]
107 new_l=[]
108 for dic in l:
109     if dic not in new_l:
110         new_l.append(dic)
111 
112 # print(new_l)
113 
114 # 其他操作
115 '''
116 # 1.长度
117 >>> s={'a','b','c'}
118 >>> len(s)
119 3
120 
121 # 2.成员运算
122 >>> 'c' in s
123 True
124 
125 # 3.循环
126 >>> for item in s:
127 ...     print(item)
128 ... 
129 c
130 a
131 b
132 '''
133 
134 # 其他内置方法
135 s={1,2,3}
136 # 需要掌握的内置方法1：discard
137 # s.discard(4) # 删除元素不存在do nothing
138 # print(s)
139 # s.remove(4) # 删除元素不存在则报错
140 
141 
142 # 需要掌握的内置方法2：update
143 # s.update({1,3,5})
144 # print(s)
145 
146 # 需要掌握的内置方法3：pop
147 # res=s.pop()
148 # print(res)
149 
150 # 需要掌握的内置方法4：add
151 # s.add(4)
152 # print(s)
153 
154 
155 
156 # 其余方法全为了解
157 res=s.isdisjoint({3,4,5,6}) # 两个集合完全独立、没有共同部分，返回True
158 print(res)
159 
160 # 了解
161 # s.difference_update({3,4,5}) # s=s.difference({3,4,5})
162 # print(s)

set

字符编码

  1 # coding:utf-8
  2 
  3 x='上'
  4 
  5 res=x.encode('gbk') # unicode--->gbk
  6 # print(res,type(res))
  7 
  8 print(res.decode('gbk'))
  9 
 10 分析过程
 11 
 12 x="上"
 13 
 14                     内存
 15 上-------翻译-----》0101010
 16 上《----翻译《-----0101010
 17 
 18 字符编码表就是一张字符与数字对应关系的表
 19 
 20 
 21 a-00
 22 b-01
 23 c-10
 24 d-11
 25 
 26 ASCII表：
 27     1、只支持英文字符串
 28     2、采用8位二进制数对应一个英文字符串
 29 
 30 GBK表：
 31     1、支持英文字符、中文字符
 32     2、
 33     采用8位（8bit=1Bytes）二进制数对应一个英文字符串
 34     采用16位（16bit=2Bytes）二进制数对应一个中文字符串
 35 
 36 
 37 unicode（内存中统一使用unicode）：
 38     1、
 39         兼容万国字符
 40         与万国字符都有对应关系
 41     2、
 42     采用16位（16bit=2Bytes）二进制数对应一个中文字符串
 43     个别生僻会采用4Bytes、8Bytes
 44 
 45 
 46     unicode表：
 47                           内存
 48         人类的字符---------unicode格式的数字----------
 49                              |                     |
 50                              |                     |
 51                              |
 52                             硬盘                    |
 53                              |
 54                              |                     |
 55                              |                     |
 56                         GBK格式的二进制       Shift-JIS格式的二进制
 57 
 58         老的字符编码都可以转换成unicode，但是不能通过unicode互转
 59 
 60 
 61 
 62 utf-8：
 63     英文->1Bytes
 64     汉字->3Bytes
 65 
 66 
 67 
 68 结论：
 69     1、内存固定使用unicode，我们可以改变的是存入硬盘采用格式
 70         英文+汉字-》unicode-》gbk
 71         英文+日文-》unicode-》shift-jis
 72         万国字符》-unicode-》utf-8
 73 
 74     2、文本文件存取乱码问题
 75         存乱了：解决方法是，编码格式应该设置成支持文件内字符串的格式
 76         取乱了：解决方法是，文件是以什么编码格式存如硬盘的，就应该以什么编码格式读入内存
 77 
 78 
 79 
 80     3、python解释器默认读文件的编码
 81         python3默认：utf-8
 82         python2默认：ASCII
 83 
 84         指定文件头修改默认的编码：
 85         在py文件的首行写：
 86             #coding:gbk
 87 
 88      4、保证运行python程序前两个阶段不乱码的核心法则：
 89         指定文件头
 90         # coding:文件当初存入硬盘时所采用的编码格式
 91 
 92 
 93      5、
 94         python3的str类型默认直接存成unicode格式，无论如何都不会乱码
 95         保证python2的str类型不乱码
 96             x=u'上'
 97 
 98 
 99     6、了解
100         python2解释器有两种字符串类型：str、unicode
101             # str类型
102             x='上' # 字符串值会按照文件头指定的编码格式存入变量值的内存空间
103             # unicode类型
104             x=u'上' # 强制存成unicode

字符编码

文件操作

 1 1、什么是文件
 2     文件是操作系统提供给用户/应用程序操作硬盘的一种虚拟的概念/接口
 3 
 4     用户/应用程序(open())
 5     操作系统（文件）
 6     计算机硬件（硬盘）
 7 
 8 2、为何要用文件
 9     用户/应用程序可以通过文件将数据永久保存的硬盘中
10     即操作文件就是操作硬盘
11 
12     用户/应用程序直接操作的是文件，对文件进行的所有的操作，都是
13     在向操作系统发送系统调用，然后再由操作将其转换成具体的硬盘操作
14 
15 3、如何用文件：open()
16         控制文件读写内容的模式：t和b
17             强调：t和b不能单独使用，必须跟r/w/a连用
18 
19             t文本（默认的模式）
20                 1、读写都以str（unicode）为单位的
21                 2、文本文件
22                 3、必须指定encoding='utf-8'
23 
24             b二进制/bytes
25 
26         控制文件读写操作的模式
27             r只读模式
28             w只写模式
29             a只追加写模式
30             +：r+、w+、a+

文件操作基本介绍

 1 # 1、打开文件
 2 # windows路径分隔符问题
 3 # open('C:\a.txt\nb\c\d.txt')
 4 # 解决方案一：推荐
 5 # open(r'C:\a.txt\nb\c\d.txt')
 6 # 解决方案二：
 7 # open('C:/a.txt/nb/c/d.txt')
 8 
 9 
10 f=open(r'aaa/a.txt',mode='rt') # f的值是一种变量，占用的是应用程序的内存空间
11 # print(f)
12 # x=int(10)
13 
14 # 2、操作文件：读/写文件，应用程序对文件的读写请求都是在向操作系统发送
15 # 系统调用，然后由操作系统控制硬盘把输入读入内存、或者写入硬盘
16 res=f.read()
17 print(type(res))
18 # print(res)
19 # 3、关闭文件
20 f.close() # 回收操作系统资源
21 # print(f)
22 # f.read() # 变量f存在，但是不能再读了
23 
24 # del f     # 回收应用程序资源
25 
26 
27 """
28 with 上下文管理机制
29 """
30 # 文件对象又称为文件句柄
31 
32 # with open('a.txt',mode='rt') as f1: # f1=open('a.txt',mode='rt')
33 #     res=f1.read()
34 #     print(res)
35 
36 
37 with open('a.txt',mode='rt') as f1,\
38         open('b.txt',mode='rt') as f2:
39     res1=f1.read()
40     res2=f2.read()
41     print(res1)
42     print(res2)
43 
44     # f1.close()
45     # f2.close()
46 
47 '''
48 强调：t和b不能单独使用，必须跟r/w/a连用
49 
50 t文本（默认的模式）
51 1、读写都以str（unicode）为单位的
52 2、文本文件
53 3、必须指定encoding='utf-8'
54 
55 '''
56 # 没有指定encoding参数操作系统会使用自己默认的编码
57 # linux系统默认utf-8
58 # windows系统默认gbk
59 with open('c.txt',mode='rt',encoding='utf-8') as f:
60     res=f.read() # t模式会将f.read()读出的结果解码成unicode
61     print(res,type(res))
62 
63 
64 
65 # 内存：utf-8格式的二进制-----解码-----》unicode
66 # 硬盘（c.txt内容：utf-8格式的二进制）

文件操作

  1 # 以t模式为基础进行内存操作
  2 
  3 # 1、r（默认的操作模式）：只读模式，当文件不存在时报错，当文件存在时文件指针跳到开始位置
  4 # with open('c.txt',mode='rt',encoding='utf-8') as f:
  5 #     print('第一次读'.center(50,'*'))
  6 #     res=f.read() # 把所有内容从硬盘读入内存
  7 #     print(res)
  8 #
  9 # # with open('c.txt', mode='rt', encoding='utf-8') as f:
 10 #     print('第二次读'.center(50,'*'))
 11 #     res1=f.read()
 12 #     print(res1)
 13 
 14 
 15 # ===============案例==================
 16 # inp_username=input('your name>>: ').strip()
 17 # inp_password=input('your password>>: ').strip()
 18 #
 19 # # 验证
 20 # with open('user.txt',mode='rt',encoding='utf-8') as f:
 21 #     for line in f:
 22 #         # print(line,end='') # egon:123\n
 23 #         username,password=line.strip().split(':')
 24 #         if inp_username == username and inp_password == password:
 25 #             print('login successfull')
 26 #             break
 27 #     else:
 28 #         print('账号或密码错误')
 29 
 30 
 31 # 应用程序====》文件
 32 # 应用程序====》数据库管理软件=====》文件
 33 
 34 # 2、w：只写模式，当文件不存在时会创建空文件，当文件存在会清空文件，指针位于开始位置
 35 # with open('d.txt',mode='wt',encoding='utf-8') as f:
 36     # f.read() # 报错，不可读
 37     # f.write('擦勒\n')
 38 
 39 # 强调1：
 40 # 在以w模式打开文件没有关闭的情况下，连续写入，新的内容总是跟在旧的之后
 41 # with open('d.txt',mode='wt',encoding='utf-8') as f:
 42 #     f.write('擦勒1\n')
 43 #     f.write('擦勒2\n')
 44 #     f.write('擦勒3\n')
 45 
 46 # 强调2：
 47 # 如果重新以w模式打开文件，则会清空文件内容
 48 # with open('d.txt',mode='wt',encoding='utf-8') as f:
 49 #     f.write('擦勒1\n')
 50 # with open('d.txt',mode='wt',encoding='utf-8') as f:
 51 #     f.write('擦勒2\n')
 52 # with open('d.txt',mode='wt',encoding='utf-8') as f:
 53 #     f.write('擦勒3\n')
 54 
 55 # 案例：w模式用来创建全新的文件
 56 # 文件文件的copy工具
 57 
 58 # src_file=input('源文件路径>>: ').strip()
 59 # dst_file=input('源文件路径>>: ').strip()
 60 # with open(r'{}'.format(src_file),mode='rt',encoding='utf-8') as f1,\
 61 #     open(r'{}'.format(dst_file),mode='wt',encoding='utf-8') as f2:
 62 #     res=f1.read()
 63 #     f2.write(res)
 64 
 65 
 66 # 3、a：只追加写，在文件不存在时会创建空文档，在文件存在时文件指针会直接调到末尾
 67 # with open('e.txt',mode='at',encoding='utf-8') as f:
 68 #     # f.read() # 报错，不能读
 69 #     f.write('擦嘞1\n')
 70 #     f.write('擦嘞2\n')
 71 #     f.write('擦嘞3\n')
 72 
 73 # 强调 w 模式与 a 模式的异同：
 74 # 1 相同点：在打开的文件不关闭的情况下，连续的写入，新写的内容总会跟在前写的内容之后
 75 # 2 不同点：以 a 模式重新打开文件，不会清空原文件内容，会将文件指针直接移动到文件末尾，新写的内容永远写在最后
 76 
 77 
 78 # 案例：a模式用来在原有的文件内存的基础之上写入新的内容，比如记录日志、注册
 79 # 注册功能
 80 # name=input('your name>>: ')
 81 # pwd=input('your name>>: ')
 82 # with open('db.txt',mode='at',encoding='utf-8') as f:
 83 #     f.write('{}:{}\n'.format(name,pwd))
 84 
 85 
 86 # 了解：+不能单独使用，必须配合r、w、a
 87 # with open('g.txt',mode='rt+',encoding='utf-8') as f:
 88 #     # print(f.read())
 89 #     f.write('中国')
 90 
 91 # with open('g.txt',mode='w+t',encoding='utf-8') as f:
 92 #     f.write('111\n')
 93 #     f.write('222\n')
 94 #     f.write('333\n')
 95 #     print('====>',f.read())
 96 
 97 #
 98 # with open('g.txt',mode='a+t',encoding='utf-8') as f:
 99 #     print(f.read())
100 #
101 #     f.write('444\n')
102 #     f.write('5555\n')
103 #     print(f.read())

文件操作详解

文件高级操作

  1 模式（控制文件操作的模式）-》了解
  2     x， 只写模式【不可读；不存在则创建，存在则报错】
  3 """
  4 # with open('a.txt',mode='x',encoding='utf-8') as f:
  5 #     pass
  6 
  7 # with open('c.txt',mode='x',encoding='utf-8') as f:
  8 #     f.read()
  9 
 10 with open('d.txt', mode='x', encoding='utf-8') as f:
 11     f.write('哈哈哈\n')
 12 
 13 
 14 
 15 控制文件读写内容的模式
 16 t：
 17     1、读写都是以字符串（unicode）为单位
 18     2、只能针对文本文件
 19     3、必须指定字符编码，即必须指定encoding参数
 20 b：binary模式
 21     1、读写都是以bytes为单位
 22     2、可以针对所有文件
 23     3、一定不能指定字符编码，即一定不能指定encoding参数
 24 
 25 总结：
 26 1、在操作纯文本文件方面t模式帮我们省去了编码与解码的环节，b模式则需要手动编码与解码，所以此时t模式更为方便
 27 2、针对非文本文件（如图片、视频、音频等）只能使用b模式
 28 """
 29 
 30 # 错误演示：t模式只能读文本文件
 31 # with open(r'爱nmlgb的爱情.mp4',mode='rt') as f:
 32 #     f.read() # 硬盘的二进制读入内存-》t模式会将读入内存的内容进行decode解码操作
 33 
 34 
 35 #
 36 # with open(r'test.jpg',mode='rb',encoding='utf-8') as f:
 37 #     res=f.read() # 硬盘的二进制读入内存—>b模式下，不做任何转换，直接读入内存
 38 #     print(res) # bytes类型—》当成二进制
 39 #     print(type(res))
 40 
 41 # with open(r'd.txt',mode='rb') as f:
 42 #     res=f.read() # utf-8的二进制
 43 #     print(res,type(res))
 44 #
 45 #     print(res.decode('utf-8'))
 46 
 47 # with open(r'd.txt',mode='rt',encoding='utf-8') as f:
 48 #     res=f.read() # utf-8的二进制->unicode
 49 #     print(res)
 50 
 51 
 52 # with open(r'e.txt',mode='wb') as f:
 53 #     f.write('你好hello'.encode('gbk'))
 54 
 55 # with open(r'f.txt',mode='wb') as f:
 56 #     f.write('你好hello'.encode('utf-8'))
 57 #     f.write('哈哈哈'.encode('gbk'))
 58 
 59 
 60 # 文件拷贝工具
 61 src_file=input('源文件路径>>: ').strip()
 62 dst_file=input('源文件路径>>: ').strip()
 63 with open(r'{}'.format(src_file),mode='rb') as f1,\
 64     open(r'{}'.format(dst_file),mode='wb') as f2:
 65     # res=f1.read() # 内存占用过大
 66     # f2.write(res)
 67 
 68     for line in f1:
 69         f2.write(line)
 70 
 71 
 72 
 73 
 74 # 循环读取文件
 75 # 方式一：自己控制每次读取的数据的数据量
 76 # with open(r'test.jpg',mode='rb') as f:
 77 #     while True:
 78 #         res=f.read(1024) # 1024
 79 #         if len(res) == 0:
 80 #             break
 81 #         print(len(res))
 82 
 83 
 84 # 方式二：以行为单位读，当一行内容过长时会导致一次性读入内容的数据量过大
 85 # with open(r'g.txt',mode='rt',encoding='utf-8') as f:
 86 #     for line in f:
 87 #         print(len(line),line)
 88 
 89 # with open(r'g.txt',mode='rb') as f:
 90 #     for line in f:
 91 #         print(line)
 92 
 93 # with open(r'test.jpg',mode='rb') as f:
 94 #     for line in f:
 95 #         print(line)
 96 
 97 
 98 
 99 三 文件的其他相关操作
100 # 一：读相关操作
101 # 1、readline：一次读一行
102 # with open(r'g.txt',mode='rt',encoding='utf-8') as f:
103 #     # res1=f.readline()
104 #     # res2=f.readline()
105 #     # print(res2)
106 #
107 #     while True:
108 #         line=f.readline()
109 #         if len(line) == 0:
110 #             break
111 #         print(line)
112 
113 # 2、readlines：
114 # with open(r'g.txt',mode='rt',encoding='utf-8') as f:
115 #     res=f.readlines()
116 #     print(res)
117 
118 # 强调：
119 # f.read()与f.readlines()都是将内容一次性读入内存，如果内容过大会导致内存溢出，若还想将内容全读入内存，
120 
121 
122 # 二：写相关操作
123 # f.writelines()：
124 # with open('h.txt',mode='wt',encoding='utf-8') as f:
125 #     # f.write('1111\n222\n3333\n')
126 #
127 #     # l=['11111\n','2222','3333',4444]
128 #     l=['11111\n','2222','3333']
129 #     # for line in l:
130 #     #     f.write(line)
131 #     f.writelines(l)
132 
133 
134 # with open('h.txt', mode='wb') as f:
135 #     # l = [
136 #     #     '1111aaa1\n'.encode('utf-8'),
137 #     #     '222bb2'.encode('utf-8'),
138 #     #     '33eee33'.encode('utf-8')
139 #     # ]
140 #
141 #     # 补充1：如果是纯英文字符，可以直接加前缀b得到bytes类型
142 #     # l = [
143 #     #     b'1111aaa1\n',
144 #     #     b'222bb2',
145 #     #     b'33eee33'
146 #     # ]
147 #
148 #     # 补充2：'上'.encode('utf-8') 等同于bytes('上',encoding='utf-8')
149 #     l = [
150 #         bytes('上啊',encoding='utf-8'),
151 #         bytes('冲呀',encoding='utf-8'),
152 #         bytes('小垃圾们',encoding='utf-8'),
153 #     ]
154 #     f.writelines(l)
155 
156 
157 # 3、flush：
158 # with open('h.txt', mode='wt',encoding='utf-8') as f:
159 #     f.write('哈')
160 #     # f.flush()
161 
162 
163 # 4、了解
164 with open('h.txt', mode='wt', encoding='utf-8') as f:
165     print(f.readable())
166     print(f.writable())
167     print(f.encoding)
168     print(f.name)
169 
170 print(f.closed)
171 
172 四 文件的高级操作-控制文件指针的移动
173 # 指针移动的单位都是以bytes/字节为单位
174 # 只有一种情况特殊：
175 #       t模式下的read(n),n代表的是字符个数
176 
177 # with open('aaa.txt',mode='rt',encoding='utf-8') as f:
178 #     res=f.read(4)
179 #     print(res)
180 
181 # f.seek(n,模式):n指的是移动的字节个数
182 # 模式：
183 # 模式0：参照物是文件开头位置
184 # f.seek(9,0)
185 # f.seek(3,0) # 3
186 
187 # 模式1：参照物是当前指针所在位置
188 # f.seek(9,1)
189 # f.seek(3,1) # 12
190 
191 # 模式2：参照物是文件末尾位置，应该倒着移动
192 # f.seek(-9,2) # 3
193 # f.seek(-3,2) # 9
194 
195 # 强调：只有0模式可以在t下使用，1、2必须在b模式下用
196 
197 # f.tell() # 获取文件指针当前位置
198 
199 # 示范
200 # with open('aaa.txt',mode='rb') as f:
201 #     f.seek(9,0)
202 #     f.seek(3,0) # 3
203 #     # print(f.tell())
204 #     f.seek(4,0)
205 #     res=f.read()
206 #     print(res.decode('utf-8'))
207 
208 
209 
210 # with open('aaa.txt',mode='rb') as f:
211 #     f.seek(9,1)
212 #     f.seek(3,1) # 12
213 #     print(f.tell())
214 
215 
216 # with open('aaa.txt',mode='rb') as f:
217 #     f.seek(-9,2)
218 #     # print(f.tell())
219 #     f.seek(-3,2)
220 #     # print(f.tell())
221 #     print(f.read().decode('utf-8'))

文件高级操作

异常处理（try..except,raise）

try:
    for i in range(10):
        try:
            print(i,"进行一些操作，成功了！")
            if i==2:
                raise Exception("我要阻止你了！") #raise主动抛出错误
        except Exception as e:
            print(e)
except Exception as e:
    print(11)
print("结束了")

raise--try(except)

try:
    print('I am sure no exception is going to occur!')
except Exception:
    print('exception')
else:
    # 这里的代码只会在try语句里没有触发异常时运行,
    # 但是这里的异常将 *不会* 被捕获
    print('This would only run if no exception occurs. And an error here '
          'would NOT be caught.')
finally:
    print('This would be printed in every case.')

try-else-finally

posted @ 2021-05-01 17:19 风hua 阅读(71) 评论(0) 编辑收藏举报

刷新页面返回顶部

第一篇 （下）python基础（二）

公告

第一篇（下）python基础（二）