第五篇.python进阶
第五篇.python进阶
1. 异常处理
1. 什么是异常
2. 异常的种类
3. 异常的处理
4. try-except总结
5. 抛出异常raise
6. 断言assert
2. 数字类型内置方法
1. 整型内置方法(int)
2.用途:
年龄、号码、等级
2.定义:
可以使用int()方法将纯数字的字符串转为十进制的整型
age = 19 # age = int(10)
print(type(age))
<class 'int'>
x = int('111')
print(type(x))
<class 'int'>
x = int('11.1') # 报错
print(x)
3.常用操作+内置方法:
算术运算+比较运算
4.存一个值or多个值:
一个值
5.有序or无序:
整型麻油有序or无序一说
6.可变和不可变
可变:变量值变了,id不变
不可变:变量值变了,id也变了
整型属于不可变:
age = 19
print(f'first:{id(age)}')
age = 20
print(f'second:{id(age)}')
first:4384901776
second:4384901808
3. 浮点型内置方法(float)
1.用途:
薪资、身高、体重
2.定义:
可以使用float()方法将纯数字的字符串转为浮点型数字。
age = 3.1 # age = float(3.1)
print(type(age))
<class 'float'>
x = float('111')
print(x)
print(type(x))
111.0
<class 'float'>
x = float('11.1') # 报错
print(type(x))
<class 'float'>
3.常用操作+内置方法:
算术运算+比较运算
4.存一个值or多个值:
一个值
5.有序or无序:
无有序or无序一说
浮点型是不可变:
salary = 3.1
print(f'first:{id(salary)}')
salary = 5.1
print(f'second:{id(salary)}')
first:4423173584
second:4423173800
4. 字符串类型内置方法
1.用途:
描述性质的东西,如人的名字、单个爱好、地址、国家等
2.定义:
使用''、""、''''''、""""""包裹的的一串字符
u'unicode': unicode编码的字符串
b'101': 二进制编码的字符串
r'\n': 原生字符串,也就是说'\n'这是普通的两个字符,并没有换行的意思
name = 'nick' # name =str('nick')
s1 = str(1.1)
s2 = str([1, 2, 3]) print(f's1:{s1}, type:{type(s1)}')
print(f's2:{s2}, type:{type(s2)}')
s1:1.1, type:<class 'str'>
s2:[1, 2, 3], type:<class 'str'>
3.常用操作+内置方法:
常用操作和内置方法分为优先掌握(今天必须得记住)、需要掌握(一周内记住)、其他操作(了解)三个部分。
1.1优先掌握
按索引取值
切片
长度len
成员运算in/not in
移除空白strip
切分split
循环
1.按索引取值(只能区,不能改变里面的东西)
# str索引取值
msg = 'hello nick'
# 0123456789 # 索引序号 print(f'索引为6: {msg[6]}')
print(f'索引为-3: {msg[-3]}')
索引为6: n
索引为-3: i
2.切片(顾头不顾尾:步长)
# 索引切片
msg = 'hello nick'
# 0123456789 # 索引序号 print(f'切片3-最后: {msg[3:]}')
print(f'切片3-8: {msg[3:8]}')
print(f'切片3-8,步长为2: {msg[3:8:2]}')
print(f'切片3-最后,步长为2: {msg[3::2]}') # 了解,步长为正从左到右;步长为负从右到左
print('\n**了解知识点**')
print(f'切片所有: {msg[:]}')
print(f'反转所有: {msg[::-1]}')
print(f'切片-5--2: {msg[-5:-2:1]}')
print(f'切片-2--5: {msg[-2:-5:-1]}')
切片3-最后: lo nick
切片3-8: lo ni
切片3-8,步长为2: l i
切片3-最后,步长为2: l ik **了解知识点**
切片所有: hello nick
反转所有: kcin olleh
切片-5--2: ni
切片-2--5: cin
3.长度len()
# str长度
msg = 'hello nick' print(len(msg))
10
4.成员运算in/not in
# str成员运算
msg = 'my name is nick, nick handsome' print(f"'nick' in msg: {'nick' in msg}")
print(f"'jason' not in msg: {'jason' not in msg}")
print(f"not 'jason' in msg: {not 'jason' in msg}")
'nick' in msg: True
'jason' not in msg: True
not 'jason' in msg: True
5.移除空白
# str移除空白strip()
name = '&&&n ick' print(f"name.strip('&'): {name.strip('&')}") # strip()默认为‘ ’,并且不修改原值,新创建空间
print(f"name: {name}") # strip()应用场景
pwd = input('password: ') # 用户可能会手抖输入空格
if pwd.strip() == '123':
print('密码输入成功') print(f"'*-& nick+'.strip('*-& +'): {'*-& nick+'.strip('*-& +')}")
name.strip('&'): n ick
name: &&&n ick
password: 123
密码输入成功
'*-& nick+'.strip('*-& +'): nick
5.切分split
# str切分split
info = 'nick:male:19'
info_list1 = info.split(':')
info_list2 = info.split(':', 1) print(f'info_list1:{info_list1}')
print(f'info_list2:{info_list2}')
info_list1:['nick', 'male', '19']
info_list2:['nick', 'male:19']
7.循环
msg = 'hello nick' for i in msg:
print(i)
1.2需要掌握
lstrip&rstrip
lower&upper
startswith&endswith
rsplit
join
replace
isdigit
.lstrip()和rstrip()
# str之lstrip()和rstrip()
name = '&&nick&&' print(f"nick.lstrip('&'): {name.lstrip('&')}")
print(f"nick.rstrip('&'): {name.rstrip('&')}")
nick.lstrip('&'): nick&&
nick.rstrip('&'): &&nick
lower()和upper()
# str之lower()和upper()
name = 'Nick Chen' print(f"name.upper(): {name.lower()}")
print(f"name.upper(): {name.upper()}")
name.upper(): nick chen
name.upper(): NICK CHEN
startswith()和endswith()
# str之startswith()和endswith()
name = 'Nick Chen' print(f"name.startswith('Nick'): {name.startswith('Nick')}")
print(f"name.endswith('chen'): {name.endswith('chen')}")
name.startswith('Nick'): True
name.endswith('chen'): False
rsplit()
# str之rsplit()
info = 'nick:male:19' print(f"info.rsplit(':', 1): {info.rsplit(':', 1)}") # 从右开始切割
info.rsplit(':', 1): ['nick:male', '19']
join()
lis = [1,2,'19']
print(f"':'.join(lis): {':'.join(lis)}") # 报错,数字不可和字符串拼接
# str之join()
lis = ['nick', 'male', '19'] print(f"':'.join(lis): {':'.join(lis)}")
':'.join(lis): nick:male:19
replace()
# str值replace()
name = 'nick shuai' print(f"name.replace('shuai','handsome'): {name.replace('shuai','handsome')}")
name.replace('shuai','handsome'): nick handsome
isdigit()
# str值isdigit()
salary = '111'
print(salary.isdigit()) # True salary = '111.1'
print(salary.isdigit()) # False
True
False
# str之isdigit()应用场景
age = input('age: ')
if age.isdigit():
age = int(age) if age < 18:
print('小姐姐')
else:
print('阿姨好')
else:
print(f'你的年龄能是这个{age}?')
age: 逗你玩?
你的年龄能是这个逗你玩??1.3其他操作
find|rfind|index|rindex|count
center|ljust|rjust|zfill
expandtabs
captalize|swapcase|title
is系列
1.find()、rfind()、index()、rindex()、count()
center()、ljust()、rjust()、zfill()
expandtabs()
captalize()、swapcase()、title()
is数字系列
is其他
5. 列表类型的内置方法
列表类型内置方法(list)
用途:多个装备、多个爱好、多门课程
定义:[]内可以有多个类型的值,逗号隔开多个元素
# my_girl_friend = list(['jason','tank','sean'])
my_girl_friend = ['jason', 'tank', 'sean'] print(f"my_girl_friend: {my_girl_friend}")
my_girl_friend: ['jason', 'tank', 'sean']
l = list('hello nick')
print(f"l: {l}")
l: ['h', 'e', 'l', 'l', 'o', ' ', 'n', 'i', 'c', 'k']
3.常用操作+内置方法:常用操作和内置方法分为优先掌握(今天必须得记住)、需要掌握(一周内记住)、其他操作(了解)三个部分。
6. 元组类型的内置方法
元组类型内置方法(tuple)
1.用途:多个装备、多个爱好、多门课程,甚至是多个女朋友
2.定义:在()内可以有多个任意类型的值,逗号分隔元素
# my_girl_friend = tuple(('jason','tank','sean'))
my_girl_friend = ('jason', 'tank', 'sean') print(f"my_girl_friend: {my_girl_friend}")
my_girl_friend: ('jason', 'tank', 'sean')
name_str = ('egon') # ()只是普通包含的意思
name_tuple = ('egon',) print(f"type(name_str): {type(name_str)}")
print(f"type(name_tuple): {type(name_tuple)}")
type(name_str): <class 'str'>
type(name_tuple): <class 'tuple'>
3.常规操作+内置方法:常用方法和内置方法
1.1 优先掌握
索引取值
切片(顾头不顾尾,步长)
长度len
成员运算in和not in
循环
count
index
1.索引取值
# tuple之索引取值
name_tuple = ('nick', 'jason', 'tank', 'sean')
# name_tuple[0] = 'nick handsom' # 报错 print(f"name_tuple[0]: {name_tuple[0]}"
name_tuple[0]: nick
2.切片(顾头不顾尾,步长)
# tuple之切片
name_tuple = ('nick', 'jason', 'tank', 'sean') print(f"name_tuple[1:3:2]: {name_tuple[1:3:2]}")
name_tuple[1:3:2]: ('jason',)
3.长度
# tuple之长度
name_tuple = ('nick', 'jason', 'tank', 'sean') print(f"len(name_tuple): {len(name_tuple)}")
len(name_tuple): 4
4.成员运算
# tuple之成员运算
name_tuple = ('nick', 'jason', 'tank', 'sean') print(f"'nick' in name_tuple: {'nick' in name_tuple}")
'nick' in name_tuple: True
5.循环
# tuple之循环
name_tuple = ('nick', 'jason', 'tank', 'sean') for name in name_tuple:
print(name)
nick
jason
tank
sean
6.count
# tuple之count()
name_tuple = ('nick', 'jason', 'tank', 'sean') print(f"name_tuple.count('nick'): {name_tuple.count('nick')}")
name_tuple.count('nick'): 1
7.index()
# tuple之index()
name_tuple = ('nick', 'jason', 'tank', 'sean') print(f"name_tuple.index('nick'): {name_tuple.index('nick')}")
name_tuple.index('nick'): 0
4.存一个值or多个值:
多个值
5.有序or无序:
有序
name_tuple = ('nick',)
print(f'first:{id(name_tuple)}')
first:4394454152
6.可变不可变:
不可变
7.元组和列表的区别
l = ['a', 'b', 'c']
print(f"id(l[0]): {id(l[0])}")
l[0] = 'A'
print(f"id(l[0]): {id(l[0])}")
id(l[0]): 4357367208
id(l[0]): 4357775176
列表可变的原因:索引对应的内存地址是可以改变的
元组不可变的原因:索引对应的值得内存地址是不可以改变的
索引对应的地址没有变,则元组的值不会变的
t1 = (['a', 'b', 'c'], 'wc', 'office') print(f"id(t1[0]): {id(t1[0])}")
print(f"id(t1[1]): {id(t1[1])}")
print(f"id(t1[2]): {id(t1[2])}") t1[0][0] = 'A'
print(f"t1[0][0]: {t1[0][0]}")
print(f"id(t1[0]): {id(t1[0])}")
print(f"t1: {t1}")
id(t1[0]): 4394709960
id(t1[1]): 4374626968
id(t1[2]): 4394453568
t1[0][0]: A
id(t1[0]): 4394709960
t1: (['A', 'b', 'c'], 'wc', 'office')
7. 字典类型的内置方法
字典类型内置方法(dict)
用途:存多个值,但每个值对应一个键,键相当于列表隐藏的索引,所以取值方法和列表有些类似
定义
{}内用逗号分隔开多个元素,每一个元素都是key:value的形式,value可以是任意数据类型,而key通常应该是字符串类型,但是key必须为不可变类型。
dic = {'a': 1, 'b': 2} # dic = dict({'a':1,'b':2}) print(f"dic: {dic}")
dic: {'a': 1, 'b': 2}
dic = dict(a=1, b=2, c=3) print(f"dic: {dic}")
dic: {'a': 1, 'b': 2, 'c': 3}
dic = {1: 'a', 0: 'b'} print(f"dic[0]: {dic[0]}") # 无法区分dic是列表,还是字典,并且key不再具有描述信息
dic[0]: b
dic = {[1,2]: 'a', 0: 'b'} # 报错1.1 优先掌握
按key存值:可存可取
长度len
成员运算in和not in
删除del
键keys()、值values()、键值对items()
循环
按key取值
# dic之按key存取值
dic = {'a': 1, 'b': 2} print(f"first dic['a']: {dic['a']}") dic['a'] = 3 print(f"second dic['a']: {dic['a']}")
first dic['a']: 1
second dic['a']: 3
2.长度len
# dic之长度len
dic = {'a': 1, 'b': 2} print(f"len(dic): {len(dic)}")
len(dic): 2
3.成员运算in和not in
# dic之成员运算in和not in
dic = {'a': 1, 'b': 2} print(f"'a' in dic: {'a' in dic}")
print(f"1 in dic: {1 in dic}")
'a' in dic: True
1 in dic: False
4.删除
# dic之删除del
dic = {'a': 1, 'b': 2}
del dic['a'] print(f"dic.get('a'): {dic.get('a')}")
dic.get('a'): None
# dic之删除pop()
dic = {'a': 1, 'b': 2}
dic.pop('a') # 指定元素删除 print(f"dic.pop('b'): {dic.pop('b')}")
print(f"dic.get('a'): {dic.get('a')}")
dic.pop('b'): 2
dic.get('a'): None
# dic之删除popitem()
dic = {'a': 1, 'b': 2} print(f"dic.popitem(): {dic.popitem()}") # popitem() 方法随机返回并删除字典中的一对键和值(一般删除末尾对)。
dic.popitem(): ('b', 2)
5.键keys()、值values()、键值对items()
# dic之键keys()、值values()、键值对items(),python2中取出的是列表(鸡蛋);python3中取出的是元组(鸡)
dic = {'a': 1, 'b': 2} print(f"dic.keys(): {dic.keys()}")
print(f"dic.values(): {dic.values()}")
print(f"dic.items(): {dic.items()}")
dic.keys(): dict_keys(['a', 'b'])
dic.values(): dict_values([1, 2])
dic.items(): dict_items([('a', 1), ('b', 2)])
6.循环
# dic之循环
# dic是无序的,但是python3采用了底层优化算法,所以看起来是有序的,但是python2中的字典是无序
dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4} for k, v in dic.items(): # items可以换成keys()、values()
print(k, v)
a 1
b 2
c 3
d 4
1.2 需要掌握(****)
- get
- update
- fromkeys
- setdefault
1.get()
# dic之get()
dic = {'a': 1, 'b': 2} print(f"dic.get('a'): {dic.get('a')}")
print(f"dic.get('c'): {dic.get('c')}")
dic.get('a'): 1
dic.get('c'): None
2.update()
# dic之update()
dic1 = {'a': 1, 'b': 2}
dic2 = {'c': 3}
dic1.update(dic2) print(f"dic1: {dic1}")
dic1: {'a': 1, 'b': 2, 'c': 3}
3.fromkeys()
# dic之fromkeys()
dic = dict.fromkeys(['name', 'age', 'sex'], None) print(f"dic: {dic}")
dic: {'name': None, 'age': None, 'sex': None}
4.setdefault()
# dic之setdefault(),有指定key不会改变值;无指定key则改变值
dic = {'a': 1, 'b': 2} print(f"dic.setdefault('a'): {dic.setdefault('a',3)}")
print(f"dic: {dic}")
print(f"dic.setdefault('c'): {dic.setdefault('c',3)}")
print(f"dic: {dic}")
dic.setdefault('a'): 1
dic: {'a': 1, 'b': 2}
dic.setdefault('c'): 3
dic: {'a': 1, 'b': 2, 'c': 3}
二.练习
统计
s='hello tank tank say hello sb sb'
中每个单词的个数结果如:
{'hello': 2, 'tank': 2, 'say': 1, 'sb': 2}
s='hello tank tank say hello sb sb' l=s.split() dic={}
for item in l:
if item in dic:
dic[item]+=1
else:
dic[item]=1
print(dic)
{'hello': 2, 'tank': 2, 'say': 1, 'sb': 2}
4.存一个值or多个值:多个值,值可以是多个类型,key必须是不可变类型,通常应该是不可变类型中的字符串类型
5.有序or无序:无序
dic = {'a': 1, 'b': 2}
print(f'first:{id(name)}')
dic['a'] = 3
print(f'second:{id(name)}')
first:4356627632
second:4356627632
6.可变or不可变:可变数据类型
8. 集合类型的内置方法
集合类型内置方法(set)
集合可以理解为集合体
pythoners = ['jason', 'nick', 'tank', 'sean']
linuxers = ['nick', 'egon', 'kevin'] # 即报名pythoners又报名linux的学生
py_li_list = []
for stu in pythoners:
if stu in linuxers:
py_li_list.append(stu)
print(f"pythoners and linuxers: {py_li_list}")
pythoners and linuxers: ['nick']
由此可见,用列表方式求两个集合体的关系比较复杂,所以就有了集合数据类型
2.定义
**{}内用逗号分隔开多个元素,每个元素必须是不可变类型。 **集合内的元素无序且集合元素不可重复,因此集合可以去重,但是去重后的集合会打乱原来元素的顺序。
s = {1, 2, 1, 'a'} # s = set({1,2,'a'}) print(f"s: {s}")
s: {1, 2, 'a'}
s = {1, 2, 1, 'a', 'c'} for i in s:
print(i)
1
2
c
a
s = set('hello') print(f"s: {s}")
s: {'e', 'o', 'h', 'l'}
1.1 优先掌握
长度len
成员运算in和not in
|并集、union
&交集、intersection
-差集、difference
^对称差集、symmetric_difference
==
父集:>、>= 、issuperset
子集:<、<= 、issubset
注意:以上的参数都为集合
练习
9. 数据类型分类
按存值个数区分
存值个数 数据类型 单个值 数字,字符串,浮点型 多个值(容器) 列表,元组,字典,集合 按可变不可变区分
可变or不可变 数据类型 可变 列表,字典,集合 不可变 数字,字符串,元组,浮点型 有序无序之分
有序or无序 数据类型 有序(可按索引取值) 字符串,列表,元组 不可变 字典,集合 按访问类型区分
访问类型 数据类型 直接访问 数字 顺序访问(序列类型) 字符串,列表,元组 key值访问(映射类型) 字典 六大类型内置方法
最新文章
- RSA IOS和Java
- 轻量级应用开发之(03)UIVIew
- IntelliJ IDEA---java的编译工具【转】
- 配置webstorm使用supervisor时出现 /usr/bin/env: node: 没有那个文件或目录 解决方法
- Wix: Show conditional message box
- 逻辑与(&;&;、&;)和逻辑或(||、|)
- jenkins 通过批处理自动构建 非标准项目
- Android安全升级的7.0: Nougat
- jforum(2)--中文乱码的解决方式
- JS第三部分--BOM浏览器对象模型
- HTML5 source标签:媒介元素定义媒介资源
- Xpath定位方法深入探讨及元素定位失败常见情况
- 引导修复软件boot-repair
- mininet下建立拓扑时关于远程控制器的一个小问题
- POJ 2685
- C#代码连接Oracle数据库一段时间以后[connection lost contact]的问题
- YouCompleteMe自动补全的安装配置与使用
- Luogu 4512 【模板】多项式除法
- .net core系列之《将.net core应用部署到Ubuntu》
- Oracle 高性能SQL引擎剖析----执行计划