第五篇.python进阶第五篇.python进阶

第五篇.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' ': 原生字符串，也就是说' '这是普通的两个字符，并没有换行的意思

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('
**了解知识点**')
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. 1.find()、rfind()、index()、rindex()、count()
2. center()、ljust()、rjust()、zfill()
3. expandtabs()
4. captalize()、swapcase()、title()
5. is数字系列
6. is其他

5. 列表类型的内置方法

列表类型内置方法（list）
1. 用途：多个装备、多个爱好、多门课程
2. 定义：[]内可以有多个类型的值，逗号隔开多个元素
```
# 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 优先掌握
1. 长度len
2. 成员运算in和not in
3. |并集、union
4. &交集、intersection
5. -差集、difference
6. ^对称差集、symmetric_difference
7. ==
8. 父集：>、>= 、issuperset
9. 子集：<、<= 、issubset
  
  注意：以上的参数都为集合
练习

9. 数据类型分类

按存值个数区分

存值个数数据类型

单个值数字，字符串，浮点型

多个值(容器) 列表，元组，字典，集合
按可变不可变区分

可变or不可变数据类型

可变列表，字典，集合

不可变数字，字符串，元组，浮点型
有序无序之分

有序or无序数据类型

有序(可按索引取值) 字符串，列表，元组

无序字典，集合
按访问类型区分

访问类型数据类型

直接访问数字

顺序访问(序列类型) 字符串，列表，元组

key值访问(映射类型) 字典
六大类型内置方法

存值个数	数据类型
单个值	数字，字符串，浮点型
多个值(容器)	列表，元组，字典，集合

可变or不可变	数据类型
可变	列表，字典，集合
不可变	数字，字符串，元组，浮点型

有序or无序	数据类型
有序(可按索引取值)	字符串，列表，元组
无序	字典，集合

访问类型	数据类型
直接访问	数字
顺序访问(序列类型)	字符串，列表，元组
key值访问(映射类型)	字典

第五篇.python进阶 第五篇.python进阶

1. 异常处理

1. 什么是异常

2. 异常的种类

3. 异常的处理

4. try-except总结

5. 抛出异常raise

6. 断言assert

2. 数字类型内置方法

1. 整型内置方法（int）

2.用途：

2.定义：

3.常用操作+内置方法：

4.存一个值or多个值：

5.有序or无序：

6.可变和不可变

3. 浮点型内置方法（float）

1.用途：

2.定义：

3.常用操作+内置方法：

4.存一个值or多个值：

5.有序or无序：

4. 字符串类型内置方法

1.用途：

2.定义：

3.常用操作+内置方法：

1.1优先掌握

5. 列表类型的内置方法

6. 元组类型的内置方法

7. 字典类型的内置方法

1.2 需要掌握(****）

二.练习

8. 集合类型的内置方法

9. 数据类型分类

相关推荐

第五篇.python进阶第五篇.python进阶