Python基础 数据类型基础
异常处理
一丶什么异常
1.语法错误
2.逻辑错误
二丶Exception
s1 = 'hello'
try:
int(s1)
except Exception as e:
print(e)二丶try...except总结
把错误处理和真正的工作分开来
代码更易组织，更清晰，复杂的工作任务更容易实现；
毫无疑问，更安全了，不至于由于一些小的疏忽而使程序意外崩溃了；
三丶抛出异常raise
try:
raise TypeError('抛出异常，类型错误')
except Exception as e:
print(e)四丶断言
assert 1 == 1
try:
assert 1 == 2
except Exception as e:
print(e)数字类型内置方法
一丶整型内置方法(int)
1.用途：年龄
2.定义：可以使用int()方法将纯数字的字符串转为十进制的整型
x = int('11.1') # 报错
print(x)二丶浮点型内置方法(float)
1.用途：薪资，身高，体重
2.定义：可以使用float()方法将纯数字的字符串转为浮点型数字。
x = float('111')
print(x)
print(type(x))111.0
<class 'float'>
3.常用操作+内置方法：算数运算+比较运算
4.存一个值or多个值：一个值
5.有序or无序：无有序无序一说
6.可变or不可变：不可变数据类型
字符串类型内置方法
1.用途：
描述性质的东西，如人的名字、单个爱好、地址、国家等
2.定义：
使用'',"",'''''',""""""包裹的一串字符
~u'unicode':uniicode编码的字符串
~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(s2)}')
print(f's2:{s2},type:{type(s2)}')s1:1.1,type:<class 'str'>
s2:[1, 2, 3],type:<class 'str'>
3.常用操作+内置方法：
1.1 优先掌握（*****************）
1.按索引取值（只可取，不可变）
name = 'shiqi zz'
# 01234567 #索引序号
print(f'索引为3：{name[3]}')
print(f'索引为5：{name[5]}')
print(f'索引为-2：{name[-2]}')索引为3：q
索引为5：
索引为-2：z
2.切片（顾头不顾尾，步长）
name = 'shiqi zz2019'
# 01234567891011 索引序号
print(f'切片-3到最后：{name[-3:]}')
print(f'切片3-8：{name[3:8]}')
print(f'切片3-8，步长为2：{name[3:8:2]}')
print(f'切片3-最后，步长为2：{name[3::2]}')
print(f'切片所有：{name[:]}')
print(f'反转所有：{name[::-1]}')
print(f'切片-5--2：{name[-5:-2]}')
print(f'切片-2--5：{name[-2-5:-1]}')切片-3到最后：019
切片3-8：qi zz
切片3-8，步长为2：q z
切片3-最后，步长为2：q z09
切片所有：shiqi zz2019
反转所有：9102zz iqihs
切片-5--2：z20
切片-2--5：102
3.长度len
name = 'shiqi zz 2019'
print(len(name))10
4.成员运算in和not in
msg = 'my name is shiqi zz,i am handsome'
print(f"'shiqi' in msg:{'shiqi' in msg}")
print(f"'nick' not in msg:{'nick' not in msg}")
print(f"not 'nick' in msg:{not 'nick' in msg} ")'shiqi' in msg:True
'nick' not in msg:True
not 'nick' in msg:True
5.移除空白strip()
name = '#@ shi qi zz&*^'
print(f"name.strip('@#^&*'):{name.strip('@#^&*')}") # strip()默认为'',并且不修改原值，新创建空间
print(f"name:{name}")
print(f"name.strip('#@ ^&*'):{name.strip('#@ ^&*')}")
name = ' shi qi '
print(f"name.strip:{name.strip()}") # strip默认切除两边空白
#strip()应用场景
pwd = input('password: ')# 用户可能会手抖输入空格
if pwd.strip() == '123':
print('密码输入成功')
name.strip('@#^&'): shi qi zz
name:#@ shi qi zz&^
password: 123
密码输入成功
name.strip('#@ ^&*'):shi qi zz
name.strip:shi qi
6.切分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)h
e
l
l
o
n
i
c
k
1.2 需要掌握（**）
name = ' #@shiqi* '
name.lstrip('#') # 左切割
name.rstrip('*') # 右切割
name.lower() # 全小写
name.upper() # 全大写
name.startswith(' ') # 判断开头为什么，返回布尔值
name.endswith('*') # 判断结尾为什么，返回布尔值
name.rstrip('*') # 从右开始切割
lis = {'nick','male','19'}
print(':'.join(lis)) #nick:male:19 拼接,必须为相同类型
name.replace('qi','ba') # 替换
name.isdigit() #判断是否为数字
列表类型内置方法
1.定义方式：[]内逗号隔开多个元素（任意数据类型）
2.使用方法
name_list = ['nick','jason','tank','sean']
# 优先掌握
name_list[0] #正向取值
name_list[-2] #反向取值
name_list[0] = 'nick handsom' # 修改值
name_list[0:3:2] # 切片
name_list # 长度
'tank' in name_list # 成员运算in 和 not in
name_list.append('shiqi') # 追加
del name_list[2] # 删除
for name in name_list:
print(name) #循环
#需要掌握
name_list.insert(0,'handsome')
print(name_list) #插入
name_list.pop(1) # 删除 默认删除最后一个
name_list.remove('nick') #删除
name_list.count('nick') #计数个数 1.2.3...
name_list.index('nick') #获取索引
name_list.clear() # 清空
name_list.copy() # 复制
l1 = [1]
l2 = [2] #合并列表
l1.extend(l1)
name_list.reverse() #列表倒序
name_list.sort() # 使用sort列表元素必须是同类型的 列表内排列字典类型内置方法
1.定义方式：{}内逗号隔开多个元素（任意数据类型）
2.使用方法
dic = {'a':1,'b':2}
dic['a'] #按k索值
dic['a'] = 3 # 按k更换值
len(dic) # 字典长度
'a' in dic #True
'1' in dic # False 成员运算
del dic['a'] # 删除
dic.pop('a') #删除指定元素
dic.keys() #dict_keys(['a', 'b']) 获取键keys
dic.values() #dict_values([1, 2]) 获取值values
dic.items() #dict_items([('a', 1), ('b', 2)]) 获取键值对items
for k,v in dic.items(): # items可以换成keys()、values()
print(k,v) # 循环
# 需要掌握
dic.get('a') # 1 获取值的个数
# dict1.update(dict2) 拼接字典
dic = dict.fromkeys(['name', 'age', 'sex'], None)
print(f"dic: {dic}")
# dic: {'name': None, 'age': None, 'sex': None} 快速生成一个字典
集合类型内置方法
元组类型内置方法
元组为不可变数据类型
在()内可以有多个任意类型的值，逗号分隔元素
使用方法和列表一样，不可更改的列表
数据类型分类
定义：{}内用逗号分隔开多个元素，每个元素必须是不可变类型。
使用方法
s = {1,2,'a'}
len(s) #长度
# 1 in s: True 成员运算in not in
#并集 s1|s2
# 交集 s1&s2
# 差集 s1-s2
# 对称差集 s1^s2
# s1==s2 判断是否相等
# s1>=s2 s1>s2 父集
# s1<s2 s1<=s2 子集
s.add(3) # 增加元素
s.remove(1) #删除元素一丶按存值个数区分
| 存值个数 | 数据类型 |
|---|---|
| 单个值 | 数字，字符串 |
| 多个值（容器） | 列表，元组，字典，集合 |
二丶按可变不可变区分
| 可变or不可变 | 数据类型 |
|---|---|
| 可变 | 列表，字典，集合 |
| 不可变 | 数字，字符串，元组 |
三丶有序无序区分
| 有序or无序 | 数据类型 |
|---|---|
| 有序（可按索引取值） | 字符串，列表，元组 |
| 不可变 | 字典，集合 |
四丶按访问类型区分
| 访问类型 | 数据类型 |
|---|---|
| 直接访问 | 数字 |
| 顺序访问（序列类型） | 字符串，列表，元组 |
| key值访问（映射类型） | 字典 |
Python深浅拷贝
一丶引言
在python中，对象赋值实际上是对象的引用。当创建一个对象，然后把它赋给另一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用
针对该列表
11 = ['a','b','c',['d','e','f']]一般有三种方法，分别为：拷贝（赋值）、浅拷贝、深拷贝
1.1丶可变or不可变
id不变值可变，即在原值的基础上修改，则为可变数据类型；值变id也变，即重新申请一个空间放入新值，则为不可变数据类型。
age = 19
print(f'first:{id(age)}')
age = 20
print(f'second:{id(age)}')first:257385936
second:257385952
二丶拷贝
如果l2是l1的拷贝对象，则l1内部的任何数据类型的元素变化，则l2内部的元素也会跟着改变，因为可变类型值变id不变。
l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = l1
l1.append('g')
print(l1)
print(l2)['a', 'b', 'c', ['d', 'e', 'f'], 'g']
['a', 'b', 'c', ['d', 'e', 'f'], 'g']
三丶浅拷贝
如果l2是l1的浅拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，则l2会跟着改变。
import copy
l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = copy.copy(l1)
l1.append('g')
print(l1)
print(l2)
l1[3].append('h')
print(l1)
print(l2)
['a', 'b', 'c', ['d', 'e', 'f'], 'g']
['a', 'b', 'c', ['d', 'e', 'f']]
['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'g']
['a', 'b', 'c', ['d', 'e', 'f', 'g']]['a', 'b', 'c', ['d', 'e', 'f'], 'g']
['a', 'b', 'c', ['d', 'e', 'f']]
['a', 'b', 'c', ['d', 'e', 'f', 'h'], 'g']
['a', 'b', 'c', ['d', 'e', 'f', 'h']]
四丶 深拷贝
如果l2是l1的深拷贝对象，则l1内的不可变元素发生了改变；如果l1内的可变元素发生了改变，l2也不会变，即l2永远不会因为l1的变化而变化。
import copy
l1 = ['a','b','c',['d','e','f']]
l2 = copy.deepcopy(l1)
l1.append('g')
print(l1)
print(l2)
l1[3].append('g')
print(l1)
print(l2)['a', 'b', 'c', ['d', 'e', 'f'], 'g']
['a', 'b', 'c', ['d', 'e', 'f']]
['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'g']
['a', 'b', 'c', ['d', 'e', 'f']]