python基础-第一篇-（从数据类型出发）
运行环境：
-
python3.8.8
-
jupyter-lab
数据类型的获取方法
- type(): 返回指定值得数据类型
type("11")
output：str
- isintance()：判断传入的值是否为指定类型
isinstance('Python你好', str)
output:True
基础数据类型（6种）
1 int:数字
2 str:字符串
3 list:列表
4 tuple:元组
5 sets:集合
6 dict:字典
print("1 %s"% type(1))
print("'11' %s"% type("1"))
print("[1] %s"% type([1]))
print("{'1':1} %s"% type({'1':1}))
print("(1,2) %s"% type((1,2)))
print("{1,2} %s"% type({1,2}))
output:
1 <class 'int'>
'11' <class 'str'>
[1] <class 'list'>
{'1':1} <class 'dict'>
(1,2) <class 'tuple'>
{1,2} <class 'set'>
不可变数据类型
不可变数据类型包括int(数字)、str(字符串)、tuple(元组),float(浮点型)、boolean(布尔型)
数字(int)类型操作
数据类型转换
int(x) ：将x转换为一个整数。
float(x)： 将x转换到一个浮点数。
complex(x, y) ：将x转换到一个复数，实数部分为 x，不传y时虚数部分为 0。
运算符‘+ - * */ // % * **’
注意的是 “/”总是返回的浮点型
type(8 / 6 )
output:
float
“//”：返回除法向下取整后的结果,
注：返回值还与分母相关，分母为浮点，则返回值也为浮点
17 % 3
output: 2
“%”：返回余数
17 // 3
output:5
**：幂运算
abs(x)
返回数字的绝对值
abs(-1)
output:1
math.xxx
-
math.ceil(x)：返回数字的上入整数
-
math.exp(x)：返回e的x次幂
-
math.floor(x)：返回数字的下舍整数
-
math.fabs(x)：返回数字的绝对值
-
math.log(x，y)：返回以y为底x的对数
-
math.log10(x)：返回以10为基数的对数
-
math.pi：圆周率
-
math.e：自然常数
-
math.modf(x)：返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
import math
x = 2.22
print(math.ceil(x))#返回数字的上入整数
output:3
x = 2
print(math.exp(x))#返回e的x次幂
output:7.38905609893065
x = 2.22
print(math.floor(x))#返回数字的下舍整数
output:2
x = -1
print(math.fabs(x))#返回数字的绝对值
output:1.0
x,y =100,10
print(math.log(x,y))#返回以y为底x的对数
output:2.0
x = 100
print(math.log10(x))#返回以10为基数的对数
output:2.0
print(math.pi)#圆周率
output:3.141592653589793
print(math.e)#自然常数
output:2.718281828459045
print(math.modf(2.1) #返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
output:(0.10000000000000009, 2.0)
max(x,y,z),min(x,y,z)
计算x,y,z中最大/最小的数
max(1,2,3)
output:3
min(1,2,3)
output:1
pow(x,y)
计算x**y 运算后的值
pow(10,2)
output:100
sqrt()
sqrt(x)返回数字x的平方根
sqrt(100)
output:10
round(x[,n])
round返回浮点数x的四舍五入
见规范输出专篇
生成随机数
见随机数专篇
字符串(str)操作
数据类型转换
str() 将指定值转为字符串类型。
str(1.222)
output:'1.222'
eval()
将字符串转换成有效的python表达式或者计算结果，也可以做数据类型的转换：
# 转换为表达式,3为int
eval("1+2")
output:3
# 数据类型的转换
res = eval("[1,2]")
type(res)
output:list
返回特定格式（居中，大小写，填充）
- str.capitalize()
返回首字母大写，其余小写的字符串
cap = 'pyThoN'.capitalize()
pirnt(cap) # 'Python'
- str.center(width,fillchar)
返回一个指定长度width的居中字符串，空余部分由fillchar指定的字符填充，fillchar默认为空格
注：fillchar只支持一个字符
center= 'Python_demo'.center(25, "-")
print(center)
output:
'-------Python_demo-------'
- str.lower() &str.upper()
str.lower() &str.upper() 将指定字符串转换为小写/大写
'PytHON'.lower()
output:python
- str.title()
title() 返回字符串中每一个单词首字母大写
'python'.title()
output:'Python'
- str.ljust() & str.rjust()
str.ljust(width,fillchar) & str.rjust(width,fillchar)实现指定宽度的左右对齐字符串
ljust_str = 'Python_demo'.ljust(15, "!")
output：‘Python_demo!!!!’
统计、 查找、定点查找
- str.count()
str.count(sub, start, end) 返回 sub 在 str 中出现的次数，可以通过 [start, end] 指定范围，若不指定，则默认查找整个字符串。
name = 'psddaaa python'
name.count('a'), name.count('p', 1)
output:(3,1)
- str.find() & str.rfind()
find() 从左往右扫描字符串，返回 sub 第一次出现的下标。可以通过 [start, end] 指定范围，若不指定，则默认查找整个字符串。如最后未找到字符串则返回 -1。
rfind则是从右往左开始扫描 ，结果与find一致
name = 'Python'
name.find('Py'), name.find('Py', 1)
output:(0,-1)
- str.index() & str.rindex()
和find类似，但是找不到值会报错ValueError: substring not found
name = 'Python'
name.index('Py', 0)
output：0
判断(字母数字大小写汉字空格首尾）
- str.isalnum()
isalnum() 判断字符串中是否所有字符都是字母/汉字/数字，是 True ，否 False，空字符串返回 False
'Python字符串12'.isalnum()
output：True
- str.isalpha()
isalpha() 判断字符串中是否所有字符都是字母/汉字，是 True ，否 False，空字符串返回 False
'Python字符串'.isalpha()
output：True
- str.isdigit()
isdigit() 判断字符串中是否所有字符都是数字(Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字)，是 True ，否 False，空字符串返回 False
- str.isspace()
字符串中只包含空格(\n换行、\r回车、\f换页、\t横向制表符、\v纵项制表符)，是 True ，否 False，空字符串返回 False
'\n\r\f\t\v'.isspace()
output:True
- str.startswith() & str.endswith
startswith(prefix[, start[, end]]) 检查字符串是否是以指定子字符串 substr 开头，是 True ，否 False，空字符串会报错。如果指定 start 和 end ，则在指定范围内检查。
startswith_str = 'Python_demo'
startswith_str.startswith('thon', 2) #从第 3 个字符开始检测
output:True
- str.istitle()
istitle() 判断字符串是否满足每一个单词首字母大写，是 True ，否 False，空字符串返回 False
- str.isupper()& str.islower()
str.isupper()& str.islower() 判断字符串所有区分大小写的字符是否都是大写/小写形式
注： 空字符串或者字符串中午区分大小写的字符返回False
切割，分割，组装
- str.lstrip() & str.rstrip() & str.strip()
str.lstrip() 会在字符串左侧根据指定的字符进行截取，若未指定默认截取左侧空格回车\r\n\t
name = '+++Python+++'
name.lstrip('+')
output：‘Python+++’
str.strip()会截取字符串两边指定的字符
- str.join(iter)
join(iterable) 以指定字符串作为分隔符，将 iterable 中所有的元素(必须是字符串)合并为一个新的字符串。
"---".join(["p","y","t"])
output:'p---y---t'
tip:
"---".join(["p"]) # 只有一个元素时不会添加分隔符
output:'p'
- str.split() & str.splitlines()
str.split(sep=None, maxsplit=-1) 使用sep做分隔符，进行分割，返回列表，maxsplit从左到右分割的最大次数
split_str = 'P y t h o n111'
split_str.split(maxsplit=2)
output:['p','y','t h o n111']
str.splitlines 返回字符串中的行列表，它按照行 ('\r'，\n'，'\r\n') 分隔，返回分隔后的列表。它只有一个参数 keepends 表示是否在结果中保留换行符，False (默认)不保留，True 保留
split_str = 'P\ny\r t hon'
split_str.splitlines(keepends=True)
output:['P\n’, ‘y\r’, ’ t hon']
tuple(元组)操作
tuple()
tuple() 将可迭代对象转换成元组
tuple([0,1,2]) + tuple(range(3)) + tuple({0,1,2}) + tuple('012')
output:(0, 1, 2, 0, 1, 2, 0, 1, 2, ‘0’, ‘1’, ‘2’)
可变数据类型
可变类型有list(列表)、dict(字典)、set(集合)
list(列表)操作
list()
list() 将可迭代对象转成列表。
list((0,1,2)) + list({0,1,2}) + list('012')
output:[0, 1, 2]
增(追加，拓展，插入)
- list.append()：追加写，在末尾添加元素
lst = ['Python', 'Java']
lst.append('C')
lst
output：[‘Python’, ‘Java’, ‘C’]
- list.extand()：扩展列表，在列表末尾添加可迭代对象，字典和集合的追加需要注意
lst = ['Python']
lst.extend('123')
output:['Python','1', '2', '3']
# 追加集合
lst = ['Python']
lst.extend({1,2,3})
lst
output:['Python','1', '2', '3']
# 追加字典，只会将key追加至末尾
lst = ['Python']
lst.extend({1: 'b', 2: 'a'})
lst
['Python', 1, 2]
- list.insert(index,object):将指定对象插入到index位置，当index大于列表长度时，元素会添加至末尾
lst = ['Python', 'Java', 'C']
lst.insert(1, 'C++')
lst
output：[‘Python’, ‘C++’, ‘Java’, ‘C’]
删
- list.pop()：移除指定位置的元素，并返回删除的元素的值，默认移除最后一个，超出长度则会报错。
lst = ['P','y','t','h','o','n']
lst.pop(1), lst
output: ('y',['P','t','h','o','n'])
-
list.remove(value)：删除列表中第一次出现的value，无返回值，直接对列表进行修改。值不存在则报错。
-
list.clear():移除列表中所有的元素，无返回值，列表为[]
改(赋值排序）
- list.reverse()：将列表本身进行逆序排列
lst = [1, 5, 9, 2]
lst.reverse()
lst
output：[2, 9, 5, 1]
- list.sort(key, reverse):对列表进行特定方式的排序，修改原列表，且元素相等时顺序不会因为排序而改变。
key:指定可迭代对象中的每个元素按照该函数进行排序，通常和lambda一起使用。
reverse: False为升序，True为降序
lst = [{"id":"2"},{"id":"5"},{"id":"3"}]
lst.sort(key=lambda x:x["id"],reverse=False)
output：
[{'id': '2'}, {'id': '3'}, {'id': '5'}]
查
-
list.index(value,start,stop)：返回列表中第一个与value匹配的元素下标。
-
list.count(value)：返回value在列表中出现的次数，无value则返回0
list.copy() # 深拷贝浅拷贝
浅拷贝通常只复制对象本身，而深拷贝不仅会复制对象，还会递归的复制对象所关联的对象。
深拷贝可能会遇到两个问题：
-
一个对象如果直接或间接的引用了自身，会导致无休止的递归拷贝；
-
深拷贝可能对原本设计为多个对象共享的数据也进行拷贝。
解决方法：deepcopy可以通过memo字典来保存已经拷贝过的对象，从而避免自引用递归问题
注：列表的切片操作[:]相当于实现了列表对象的浅拷贝
- copy:
- 当最外层对象为可变类型时，copy后得到的对象指向新的内存空间，当最外层的对象为不可变类型时，copy后得到的对象指向原对象的内存空间（注意：浅拷贝的对象的最外层是否是可变类型）
- deepcopy：除拷贝对象本身，还拷贝对象中引用的其他对象
- 拷贝的内容中只要有一个是个可变类型，那么deepcopy一定是深拷贝
>>> a = [1, 2, 3]
>>> b = list(a)
>>> print(id(a), id(b))
# a和b身份不同
140601785066200 140601784764968
>>> for x, y in zip(a, b): # 但它们包含的子对象身份相同...
print(id(x), id(y))
...
140601911441984 140601911441984
140601911442016 140601911442016
140601911442048 140601911442048
注：深拷贝只有一种方式：copy模块中的deepcopy函数。
1、赋值：简单地拷贝对象的引用，两个对象的id相同。
2、浅拷贝：创建一个新的组合对象，这个新对象与原对象共享内存中的子对象。
3、深拷贝：创建一个新的组合对象，同时递归地拷贝所有子对象，新的组合对象与原对象没有任何关联。虽然实际上会共享不可变的子对象，但不影响它们的相互独立性。
dict(字典)操作
dict.clear()
clear() 清除字典的所有内容
dic = {'clear': 'clear',}
dic.clear()
dic
output：{}
dict.fromkeys()
fromkeys() 创建一个新字典，以序列 iterable 中元素做字典的键，value 为字典所有键对应的初始值
-
iterable： 可迭代对象，新字典的键
-
value： 可选参数, 设置键序列对应的值，默认为
None
dict.fromkeys(['key1', 'key2'],'Python')
output：{‘key1’: ‘Python’, ‘key2’: ‘Python’}
dict.get()
get(key, default=None) 根据指定的 key 值查找，如果 key 在字典中，则返回 key 的值，否则为 None
dic = {'get_value': 'demo01'}
dic.get('get_value')
output:'demo01'
dict.items()
items() 返回视图对象，是一个可遍历的 key/value 对，可以使用 list() 将其转换为列表
dic = {'key01': 'value01',
'key02': 'value02'}
list(dic.items())
output:[('key01','value01'),('key02','value02')]
dict.keys()
keys() 返回一个视图对象，值为字典的 key ，可将其转换成列表
dic = {'key01': 'value01',
'key02': 'value02'}
dic.keys()
output:dict_keys(['key01',key02'])
dict.setdefault()
setdefault(key, default=None) 如果键不在字典中，则插入值为 None 的键。如果键在字典中，则返回键的值
dic = {'key01': 'value01',
'key02': 'value02'}
dic.setdefault('key02','value03)
output:'value02'
dic = {'key01': 'value01',
'key02': 'value02'}
dic.setdefault('key03','value03)
dic
output:{'key01': 'value01',
'key02': 'value02'
'key03':'value03'}
dict.update()
dict.update(dict1) 把字典 dict1 的 key/value 对更新到 dict 里，当 dict1 的 key 出现在 dict 中则修改 dict 中的值，如果 key 没有出现在 dict 中，则添加这一对 key/value
dic1 = {'key01': 'value01',
'key02': 'value02'}
dic2 = {'key01': 'value01',
'key02': 'value02'}
dic1.update(dict2)
dic1
output:{'key01': 'value01',
'key02': 'value02',
'key01': 'value01',
'key02': 'value02'}
dict.values()
values() 返回一个视图对象，值为字典的 value ，可将其转换成列表
dic = {'key01': 'value01',
'key02': 'value02'}
dic.values()
output:dict_values([‘value01’, ‘value02’])
dict.pop() & dict.popitem()
dict.pop() 删除指定 key 的 key/value ，如果 key 没有找到，则报错
popitem() 删除字典中末尾的元素，并返回一个元组的(键，值)对。字典为空则报错
dic = {'key01': 'value01',
'key02': 'value02'}
dic.pop('key01')
dic
output:{'key02':'value02'}
dic = {'key01': 'value01',
'key02': 'value02'}
dic.popitem()
output:{'key02':'value02'}
set（集合）
set.add()
向集合中添加一个元素，但如果该元素已经出现在集合中，则不起作用
注：如果add的元素已经在集合中 集合不会发生变化
set1 = {'set01','set02','set03'}
set1.add('python')
set1
output:{'set01','set02','set03','python'}
set.clear()
clear() 移除集合中的所有元素
set1 = {'python'}
set1.clear()
set1
output：set()
set.difference() & set.difference_update()
difference() 返回多个集合的差集，通俗来讲就是返回第一个 set 中哪些元素没有在其他 set 中出现
difference_update() 方法与 difference() 方法的区别在于 difference() 方法返回一个移除相同元素的新集合，而 difference_update() 方法是直接移除原集合中的元素，无返回值
set1 = {'set01',
'c++',
'python'}
set2 = {'python', 'c++'}
set3 = {'Python'}
set1.difference(set2, set3)
output：{'set01'}
set1 = {'set01',
'c++',
'python'}
set2 = {'python', 'c++'}
set3 = {'Python'}
set1.difference_update(set2, set3)
set1
output：set()
set.discard()
discard() 删除集合中指定的元素。如果指定移除的元素不在集合中，则不移除
set1 = {'set01','set02','set03'}
set1.discard('set01')
output:{'set02','set03'}
set.intersection() & set.intersection_update()
-
intersection()返回集合的交集。没有交集则返回空集set() -
intersection_update()方法与intersection()方法的区别在于intersection()方法将集合的交集作为新集合返回，而intersection_update()方法是直接修改原集合中的元素，只保留交集元素，无返回值。
set1 = {'set01','set02','set03'}
set2 = {'set01', 'c++'}
set03 = {'set01'}
set1.intersection(set2, set3)
output:{'set01'}
set1 = {'set01','set02','set03'}
set2 = {'set01', 'c++'}
set03 = {'set01'}
set1.intersection_update(set2, set3)
set1
output:{'set01'}
set.isdisjoint()
isdisjoint() 判断两个集合是否包含相同的元素，有则返回 False，无则返回 True
set1 = {'set01','set02','set03'}
set2 = {'set01','set02'}
set1.isdisjoint(set2)
output:False
set.issubset()&set.issuperset()
-
issubset(set1)判断集合set2是否为set1集合的子集。是则返回True，否则返回False -
issuperset(set2)判断集合set2是否为set1集合的子集。是则返回True，否则返回False。它与issubset()用法相同，只有参数的位置相反而已
set1 = {'set01','set02','set03'}
set2 = {'set01','set02'}
set2.issubset(set1)
output:True
set1 = {'set01','set02','set03'}
set2 = {'set01','set02'}
set1.issuperset(set2)
output:True
set1.pop()&set.remove()
-
pop()移除并返回集合中的任意元素。如果该集合为空集则报错 -
remove()从集合中移除指定的元素，如果该元素不在集合中，则发生报错
set1 = {'set01','set02','set03'}
set1.pop()
output:'set03'
set1.remove('set01')
set1
output:{'set02'}
set.symmetric_difference()&set.symmetric_difference_update()
-
symmetric_difference()返回两个集合中不重复的元素集合，即两个集合的补集，与^的作用相同 -
symmetric_difference_update(set2)移除set1中在set2相同的元素，并将set2集合中不同的元素插入到set1中。简单来说就是把set1与set2的补集赋值给set1
set1 = {'set01','set02','set03'}
set2 = {'set01','set02'}
set1.symmetric_difference(set2) ==> set1 ^ set2
output:{'set03'}
set1 = {'set01','set02','set03'}
set2 = {'set01','set02'}
set1.symmetric_difference_update(set2) ==>set1 = set1 ^ set2
set1
output:{'set03'}
set.union()
union() 返回多个集合的并集。与 | 的作用相同
set1 = {'set01','set02','set03'}
set2 = {'set01','set02','set04'}
set3 = {'set01','set02','set05'}
set1.union(set2, set3)
output:{'set01','set02','set03','set04','set05'}
set.update()
update() 使用本身和其他的联合来更新集合
set1 = {'set01','set02','set03'}
set1.update([1,2,3])
output:{'set01','set02','set03',1,2,3}
202
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
