Python 是一款易于学习且功能强大的编程语言。 它具有高效率的数据结构,能够简单又 有效地实现面向对象编程。Python 简洁的语法与动态输入之特性,加之其解释性语言的 本质,使得它成为一种在多种领域与绝大多数平台都能进行脚本编写与应用快速开发工 作的理想语言。
Python主要版本:Python2 与 Python3 截止2023年6月10日,目前Python2 最后一个版本为2.7.18。 Python3 的最新版本为:3.11.4
环境搭建与脚本结构
环境搭建
Python包: 从python官网上下载版本 , 根据自己的操作系统进行下载安装即可
IDE工具: 建议安装PyCharm, 推荐下载地址
脚本结构
graph TD;
完整结构-->头部注释区域;
完整结构-->导入区域;
完整结构-->代码区域;
代码区域-->代码执行顺序;
代码区域-->代码的注释;
完整结构-->代码执行入口;
头部注释区域
# 告诉系统脚本是何编码格式
# coding:utf-8
导入区域
就是导入系统,第三方或者自己封装包/模块,
import os
代码区域
故名思义就是写代码和注释的地方
注释方式有三种语法
- 第一种: #号注释
# 看到这行代码的人,注意了.这是一个测试代码
- 第二种: 三引号注释
"""
这是三引号注释的第一种 双引号形式,可以随意换行
"""
- 第三种: 单引号注释
'''
这是三引号注释的第二种 功能与双引号一样
'''
代码的执行入口
if __name__ == '__main__':
完整代码结构
# coding:utf-8
import os
# 打印路径
def print_cwd():
print(os.getcwd())
if __name__ == '__main__':
print_cwd()
关键字与变量名
关键字
关键字: Python内部自带的用于处理业务逻辑的特殊单词
常见的关键字
关键字 | 含义 |
---|---|
True | 布尔类型,表示真 |
False | 布尔类型,表示否 |
None | |
def | 函数定义 |
if | 逻辑中的如果 |
elif | 逻辑中的或者如果 |
else | 逻辑中的否则 |
try | 异常语句的开启 |
except | |
finally | |
is | 判断变量是否是某个类的实例 |
not | 逻辑运算,非的操作 |
or | 布尔类型,表示真 |
pass | 无意义,站位字符 |
raise | 主动抛出异常 |
in | 判断变量是否在序列中 |
while | While循环语句 |
break | |
continue | |
return | |
as | |
with | 简化python语句 |
yield | 从循环或函数依次返回数据 |
import | 导入语句,可与from共用 |
del | |
class | 类 |
变量名
变量名: 用于给变量赋值使用
数据类型
Python的数据类型分为:数字类型、字符串类型、布尔类型、空类型、列表类型、元祖类型、字典类型
内置函数
type 获取变量的数据类型
num1 = 100
type(num1) # <class 'int'>
id 返回变量内存地址
num1 = 100
id(num1) # 4471838160 内存地址
num1 = 200 # 修改后内存会不同,不同区域
id(num1) # 4444832400 内存地址
print 输出变量的数据
print函数默认每行都换行,函数中添加end='' 可另下一行不换行
name = 'abc'
print('输出变量name:',name,end='')
print('输出变量name:',name)
数字类型
分为整型int 、浮点型float
count_100 = int(100)
pi_01 = float(3.14)
print(type(count_100)) # <class 'int'>
print(type(pi_01)) # <class 'float'>
数字类型的常用方法
方法 | 描述 | 用法 |
---|---|---|
abs(x) | 返回数字的绝对值 | abs(-1) 结果:1 |
math.ceil(x) | 数字的向上整数 | import math math.ceil(4.1) 结果:5 |
math.exp(x) | 返回e的x次幂(ex) | import math math.exp(1) 结果:2.718281828459045 |
math.fabs(x) | 以浮点数形式返回数字的绝对值 | import math math.fabs(-10) 结果: 10.0 |
math.floor(x) | 数字的向下整数 | import math math.floor(1.9) 结果:1 |
math.log(x,y) | 返回自然对数,可传两个参数,最少传1个 | import math math.log(10) math.log(100,10) 结果:2.302585092994046 结果:2.0 |
math.log10(x) | 返回以10为基数的x的对数 | import math math.log10(100) 结果:2.0 |
math.max(x1,x2,x3,...) | 返回给定参数的最大值,参数可以为序列。 | max(100,200,300) max([100,200,300]) 结果:300 |
min(x1,x2,x3,...) | 返回给定参数的最小值,参数可以为序列。 | min(100,200,300) min([100,200,300]) 结果:100 |
math.modf(x) | 返回x的整数部分与小数部分,两部分的数值符号与x相同,整数部分以浮点型表示。 | import math math.modf(100.12) 结果:(0.12000000000000455, 100.0) |
pow(x,y) | 幂运算 | pow(10,3) 结果:1000 |
round(x,y) | 返回浮点数 x 的四舍五入值,如给出 y 值,则代表舍入到小数点后的位数。 | round(3.141516) round(3.141516,2) 结果: 3 结果: 3.14 |
math.sqrt(x) | 返回数字x的平方根。 | import math math.sqrt(9) 结果: 3 |
random.choice(x) | 从序列的元素中随机挑选一个元素,比如random.choice(range(10)),从0到9中随机挑选一个整数。 | import random random.choice(range(100)) 结果: 48 |
random.randrange(startNumber,stopNumber,step) | 从指定范围内,按指定基数递增的集合中获取一个随机数,基数默认值为 1 | import random random.randrange(1,10) 结果:2 |
random.random() | 随机生成一个数,范围在0到1范围内 | import random |
random.seed(x) | 改变随机数生成器的种子seed。如果你不了解其原理,你不必特别去设定seed,Python会帮你选择seed。 | import random random.seed(10) random.random() 结果:0.5714025946899135 |
random.shuffle(list) | 将序列的所有元素随机排序 | import random list = [8,1,2,71,3,5,6] random.shuffle(list) 结果:[6, 8, 1, 5, 3, 2, 71] |
random.uniform(x,y) | 随机生成下一个实数,它在[x,y]范围内。 | import random random.uniform(10,20) 结果: 17.542500061038616 |
math.acos(x) | 返回x的反余弦弧度值。x -- -1到1之间的数值。如果x是大于1 | import math math.acos(-1) 结果:3.141592653589793 |
math.asin(x) | 返回x的反正弦弧度值。- x -- -1到1之间的数值。如果x是大于1,会产生一个错误。 | import math math.asin(-1) 结果:-1.5707963267948966 |
math.atan(x) | 返回x的反正切弧度值。 | import math math.atan(10) 结果: 1.4711276743037345 |
math.atan2(x,y) | 返回给定的 X 及 Y 坐标值的反正切值。 | import math math.atan2(10,20) 结果: 0.4636476090008061 |
math.cos(x) | 返回x的弧度的余弦值。 | import math math.cos(5) 结果: 0.2836621854632263 |
math.hypot(x,y) | 返回欧几里德范数 sqrt(xx + yy)。 | import math math.hypot(3,5) 结果: 5.8309518948453 |
math.sin(x) | 返回的x弧度的正弦值。 | import math math.sin(3) 结果:0.1411200080598672 |
math.tan(x) | 返回x弧度的正切值。 | import math math.tan(3) 结果: -0.1425465430742778 |
math.degrees(x) | 将弧度转换为角度,如degrees(math.pi/2) , 返回90.0 | import math math.degrees(3) 171.88733853924697 |
math.radians(x) | 将角度转换为弧度 | import math math.radians(180) 结果: 3.141592653589793 |
字符串类型
str 代表字符串类型
name = str('tony')
type(name) # <class 'str'>
字符串类型的常用方法
方法 | 描述 | 用法 |
---|---|---|
capitalize() | 首字母大写,其他字母小写,不改变原来字符串 | example_str = 'aBcDefg' new_str = example_str.capitalize() 结果: new_str # Abcdefg 结果: example_str #aBcDefg |
lower() | 将字符串全体小写 | example_str = 'aBcDefg' new_str = example_str.lower() 结果: new_str # abcdefg 结果: example_str #aBcDefg |
casefold() | 将字符串全体小写, 更多小语种 | example_str = 'aBcDefg' new_str = example_str.casefold() 结果: new_str # abcdefg 结果: example_str #aBcDefg |
upper() | 将字符串全体大写 | example_str = 'aBcDefg' new_str = example_str.upper() 结果: new_str # ABCDEFG 结果: example_str #aBcDefg |
swapcase() | 大小写字母互换 | example_str = 'aBcDefg' new_str = example_str.swapcase() 结果: new_str # AbCdEFG 结果: example_str #aBcDefg |
zfill(width) | 为字符串定义长度,不满足,缺少的部分用0替代,width:新字符串希望的宽度 | example_str = 'aBcDefg' new_str = example_str.zfill(10) 结果: new_str # 000aBcDefg 结果: example_str #aBcDefg |
count(x) | 返回当前字符串中某个成员的个数,x:查找个数的元素 | example_str = 'aBcDefgB' new_str = example_str.count('B') 结果: new_str # 2 结果: example_str #aBcDefg |
startswith(str) | 字符串中开头是否包含某个字符,返回bool | example_str = 'aBcDefg' new_str = example_str.startswith('a') 结果: new_str # True 结果: example_str #aBcDefg |
endswith(str) | 字符串中结尾是否包含某个字符,返回bool | example_str = 'aBcDefg' new_str = example_str.startswith('a') 结果: new_str # True 结果: example_str #aBcDefg |
lstrip() | 去除左侧空格 | example_str = ' aBcDefg' new_str = example_str.lstrip() 结果: new_str # aBcDefg 结果: example_str #aBcDefg |
rstrip() | 去除右侧空格 | example_str = 'aBcDefg ' new_str = example_str.rstrip() print(new_str,end='') print('=====') 结果: aBcDefg===== 结果: aBcDefg ===== |
strip() | 去除左右空格 | example_str = 'aBcDefg ' new_str = example_str.strip() print(new_str,end='') print('=====') 结果: aBcDefg===== 结果: aBcDefg ===== |
len(x) | 获取字符串长度,x是字符串类型的变量 | example_str = 'aBcDefg' len(example_str) 结果: 7 |
str(x) | 把类型转为字符串,x是字符串类型的变量 | num1 = 123 example_str = str(num1) type(example_str) type(num1) 结果: <class 'str'> 结果: <class 'int'> |
find(x) | 字符是否在字符串中,存在则返回指定索引,否则返回-1 | example_str = 'aBcDefg' num_result = example_str.find('D') 结果: 3 |
index() | 字符是否在字符串中,存在则返回指定索引,不存在则报错 | example_str = 'aBcDefg' num_result = example_str.index('D') num_result 结果: 3 |
replace(x,y,[z]) | 替换字符串,x为需要替换字符串,y是替换后的字符串,z为替换的数量(可选) | example_str = 'aBcDefg,D' new_str = example_str.replace('D','d') new_str 结果: aBcdefg,d example_str 结果: aBcDefg,D |
isspace() | 字符串是否是一个由空格组成,返回bool | example_str = 'aBcDefg, D' bool_result = example_str.isspace() bool_result 结果: False |
istitle() | 判断字符串是否是一个标题类型,通过是否由多个单词,并且每个单词首字母大写进行判断, | example_str = 'My Name' bool_result = example_str.istitle() bool_result 结果: True |
isupper() | 判断字符串中的字母是否都是小写 | example_str = 'AbcDE' bool_result = example_str.isupper() bool_result 结果: False |
islower() | 判断字符串中的字母是否都是小写 | example_str = 'AbcDE' bool_result = example_str.islower() bool_result 结果: False |
split() | 字符串以某种字符分割成为列表 | example_str = 'Abc,D,E' bool_result = example_str.split(',') bool_result 结果: ['Abc', 'D', 'E'] |
format | 字符串格式化 |
字符串格式化的几种方法
百分号格式化(%)
# 注意,参数需要全部填写,缺少一个参数,代码会报错
result_str = '我的名字叫%s,今年%s岁,住在%s' %('tony',18,'中国广州')
print(result_str) # 我的名字叫tony,今年18岁,住在中国广州
result_str2 = '我的名字叫%s,今年%s岁,住在%s'
print(result_str2 %('tony',18,'中国广州')) # 我的名字叫tony,今年18岁,住在中国广州
format函数格式化
info_str = 'hello {} , 今天的天气 {}'.format('tony','非常好')
print(info_str) # hello tony , 今天的天气 非常好
变量作为参数
3.6版本后才支持
name = 'tony'
age = 18
info_str = f'我叫{name} , 今年{age}'
print(info_str) #我叫tony , 今年18
格式化符号
用于对应各种数据类型的格式符号
符号 | 说明 |
---|---|
%s | 格式化字符串,通用类型 |
%d | 格式化整型 |
%f | 格式化浮点型 |
%u | 格式化无符号整型(正整型) |
%c | 格式化字符 |
%o | 格式化无符号八进制数 |
%x | 格式化无符号16进制数 |
%e | 科学计数法格式化浮点数 |
转义字符
符号 | 说明 |
---|---|
\n | 换行符,strip对其也有效 |
\t | 横行制表符 |
\v | 纵向制表符 |
\a | 响铃 |
\b | 退格符,将光标前移,删除前一个 |
\r | 回车 |
\f | 翻页 |
' | 转义字符串中的单引号 |
" | 转义字符串中的双引号 |
\ | 转义斜杠 |
布尔类型
通过bool进行定义,返回是True / False, 0 转义为False , 也就是非0就为True
result = bool(1)
print(result) # False
空类型
不属于任何数据类型就是空类型 固定值:None 空类型属于False的范畴
test = None
print(test) # None
print(type(test)) # <class 'NoneType'>
列表类型
列表是 Python 中最基本的数据结构。
列表中的每个值都有对应的位置值,称之为索引,第一个索引是 0,第二个索引是 1,依此类推。
反向索引
num_list = [1,2,3,4,5]
print(num_list[-2]) # 4
# 使用方括号 [] 的形式截取字符
print(num_list[0:2]) # [1, 2]
操作符
+ 号
num_list = [1,2,3,4,5]
new_list = num_list + num_list
print(new_list) # [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
*号
num_list = [1,2,3,4,5]
new_list = num_list * 3
print(new_list) # [1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
列表比较
import operator
a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b)) # operator.eq(a,b): False
print("operator.eq(c,b): ", operator.eq(c,b)) # operator.eq(c,b): True
列表类型的常用方法
方法 | 描述 | 用法 |
---|---|---|
len | 获取数组长度 | num_list = [1,2,3,4,5] len(num_list) 结果:5 |
in | 数据是否包含在数组中,返回bool | num_list = [1,2,3,4,5] 1 in num_list 结果: True |
not in | 数据是否不包含在数组中,返回bool | num_list = [1,2,3,4,5] 1 not in num_list 结果: False |
append | 添加数据,修改原数组 | num_list = [1,2,3,4,5] num_list.append(6) 结果: [1,2,3,4,5,6] |
del | 删除列表元素,修改原数组 | num_list = [1,2,3,4,5] del num_list[0] 结果: [2,3,4,5] |
max | 返回列表元素最大值 | num_list = [6,1,2,3,4,5] max_rexult = max(num_list) max_result 结果:6 |
min | 返回列表元素最小值 | num_list = [6,1,2,3,4,5] min_rexult = min(num_list) min_result 结果:1 |
list | 将元组转换为列表 | tuple_data = (1,2,3,4,5) list_data = list(tuple_data) type(list_data) 结果: <class 'list'> type(tuple_data) 结果: <class 'tuple'> |
count | 统计某个元素在列表中出现的次数 | num_list = [1,2,3,4,5] result = num_list.count(3) result 结果:1 |
extend | 在列表末尾一次性追加另一个序列中的多个值 | num_list = [1,2,3,4,5] str_list = ['a','b','c','d'] num_list.extend(str_list) 结果: [1, 2, 3, 4, 5, 'a', 'b', 'c', 'd'] |
index | 从列表中找出某个值第一个匹配项的索引位置不满足代码则会报错 | num_list = [1,2,3,4,5,'a'] num_list.index('a') 结果: 5 |
insert | 在指定索引位置插入数据 | num_list = [1,2,3,4,5] num_list.insert(1,10) 结果: [1, 10, 2, 3, 4, 5] |
pop | 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值 | num_list = [1,2,3,4,5] num_list.pop(3) 结果: [1, 2, 3, 5] |
remove | 移除列表中某个值的第一个匹配项, 不存在则报错 | num_list = ['a',1,2,3,4,5] num_list.remove('a') 结果: [1, 2, 3, 4, 5] |
reverse | 反向列表中元素 | num_list = ['a',1,2,3,4,5] num_list.reverse() 结果: [5, 4, 3, 2, 1, 'a'] |
sort | 对原列表进行排序 | num_list = [1,3,4,5,2] num_list.sort() 结果:[1, 2, 3, 4, 5] |
clear | 清空列表 | num_list = [1,3,4,5,2] num_list.clear() 结果:[] |
copy | 复制列表 | num_list = [1,3,4,5,2] num_list2 = num_list.copy() num_list.append(10) id(num_list),num_list 结果: 4476995008 [1, 3, 4, 5, 2, 10] id(num_list2),num_list2 结果: 4477002496 [1, 3, 4, 5, 2] |
元祖类型
tuple代表元组类型,元组的元素存在于一个()小括号中
列表与元组的区别
列表是可变,元组是不可变,所以元组比列表占用的资源更小
tuple_data = (1,2,3,3)
元组类型的常用方法
方法 | 描述 | 用法 |
---|---|---|
del | 删除元组 | tuple_data = (1,2,3,3) del tuple_data |
len() | 计算元组元素个数。 | tuple_data = (1,2,3,3) len(tuple_data) 结果:4 |
max() | 返回元组中元素最大值。 | tuple_data = (1,2,3,3) max(tuple_data) 结果:3 |
min() | 返回元组中元素最小值 | tuple_data = (1,2,3,3) min(tuple_data) 结果:1 |
tuple() | 将可迭代系列转换为元组。 | list_data = [1,2,3,3] tuple_data = tuple(list_data) type(list_data) 结果:<class 'list'> type(tuple_data) 结果: <class 'tuple'> |
count(x) | 统计元组中指定参数的个数,不能为空,不存在则返回0 | tuple_data = (1,2,3,3) tuple_data.count(3) 结果: 2 |
index(x,y) | 获取元组中指定参数对应的索引,x为指定参数, y为从哪个位置开始获取(可选),参数不存在则报错 | tuple_data = (1,2,3,3) tuple_data.index(3) 结果:2 tuple_data(3,3) 结果:3 |
in | 参数是否包含在元组中 | tuple_data = (1,2,3,3) 1 in tuple_data 结果: True |
not in | 参数是否不包含在元组中 | tuple_data = (1,2,3,3) 10 not in tuple_data 结果: True |
字典类型
字典类型可通过dict
关键字或者直接使用{}
进行定义
# 字典的定义
example1 = dict({'a':10})
exmaple2 = {'a':10}
# 输出对应的值
example1['a']
# 修改字典
example1['a'] = 20
字典类型的常用方法
方法 | 描述 | 用法 |
---|---|---|
del | 删除键 | dict_01 = {'name': 'tony'} del dict_01 |
len(x) | 获取键的个数 | dict_01 = {'name': 'tony'} len(dict_01) 结果: 1 |
clear() | 删除字典内所有元素 | dict_01 = {'name': 'tony'} dict_01.clear() dict_01 结果: {} |
copy() | 返回一个字典的浅复制 | dict_01 = {'name': 'tony'} dict_02 = dict_01.copy() |
fromkeys(tuple) | 创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值 | tuple_01 = ('name','age','sex') dict_01 = dict.fromkeys(tuple_01) 结果: {'name': None, 'age': None, 'sex': None} |
get(x) | 返回指定键的值,如果键不在字典中返回 None | dict_01 = {'name': 'tony'} dict_01.get('name1') 结果: None |
key in dict | 如果键在字典dict里返回true,否则返回false | dict_01 = {'name': 'tony'} 'name' in dict_01 结果: True |
items() | 以列表返回一个视图对象 | dict_01 = {'name': 'tony','age' : 18} dict_01.items() 结果: dict_items([('name', 'tony'), ('age', 18)]) |
keys | 返回对象中的键 | dict_01 = {'name': 'tony','age' : 18} dict_01.keys() 结果: dict_keys(['name', 'age']) |
setdefault(x,y) | 键不存在于字典中,将会添加键并将值设为默认值。 | dict_01 = {'name': 'tony','age' : 18} dict_01.setdefault('sex','男') 结果: {'name': 'tony', 'age': 18, 'sex': '男'} |
update(dict) | 把字典dict2的键/值对更新到dict里 | dict_01 = {'name': 'tony','age' : 18} dict_02 = {'sex' : '男'} dict_01.update(dict_02) 结果: {'name': 'tony', 'age': 18, 'sex': '男'} |
values() | 返回一个视图对象 | dict_01 = {'name': 'tony','age' : 18} dict_01.values() 结果: dict_values(['tony', 18]) |
pop(x) | 删除字典 key(键)所对应的值,返回被删除的值。 | dict_01 = {'name': 'tony','age' : 18} dict_01.pop('name') 结果: {'age': 18} |
popitem() | 返回并删除字典中的最后一对键和值。 | dict_01 = {'name': 'tony','age' : 18} dict_01.popitem() 结果: {'name': 'tony'} |
集合类型
集合(set)是一个无序的不重复元素序列。可以使用大括号 { }
或者 set()
函数创建集合,注意:创建一个空集合必须用 set()
而不是 { }
,因为 { }
是用来创建一个空字典。
方法 | 描述 | 用法 |
---|---|---|
add() | 为集合添加元素 | set_data = {'a','b','c'} set_data.add('d') 结果: {'a', 'd', 'c', 'b'} |
clear() | 移除集合中的所有元素 | set_data = {'a','b','c'} set_data.clear() 结果: set() |
copy() | 拷贝一个集合 | set_data = {'a','b','c'} set_data2 = set_data.copy() |
difference() | 返回多个集合的差集 | set_data = {'a','b','c'} set_data2 = {'c','d','e'} set_data.difference(set_data2) 结果: {'a', 'b'} |
difference_update() | 移除集合中的元素,该元素在指定的集合也存在。 | set_data = {'a','b','c'} set_data.difference_update('a') 结果: {'b', 'c'} |
discard() | 删除集合中指定的元素 | set_data = {'a','b','c'} set_data.discard('b') 结果: {'c', 'a'} |
intersection() | 返回集合的交集,不修改自身 | set_data = {'a','b','c'} set_data2 = {'a','f','g'} set_data.intersection(set_data2) 结果:{'a'} |
intersection_update() | 返回集合的交集,修改自身 | set_data = {'a','b','c'} set_data2 = {'c','f','g'} set_data.intersection_update(set_data2) 结果: {'c'} |
isdisjoint() | 判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。 | set_data = {'a','b','c'} set_data2 = {'c','f','g'} set_data.isdisjoint(set_data2) 结果: False |
issubset() | 判断指定集合是否为该方法参数集合的子集。 | set_data = {'a','b','c'} set_data2 = set_data set_data.issubset(set_data2) 结果: True |
issuperset() | 判断该方法的参数集合是否为指定集合的子集 | set_data = {'a','b','c'} set_data2 = {'c'} set_data.issuperset(set_data2) 结果: True |
pop() | 随机移除元素 | set_data = {'a','b','c'} set_data.pop() 结果: {'a','c'} |
remove(x | 移除指定元素 | set_data = {'a','b','c'} set_data.remove('a') 结果: {'b', 'c'} |
symmetric_difference() | 返回两个集合中不重复的元素集合。 | set_data = {'a','b','c'} set_data2 = {'c','d','e'} set_data.symmetric_difference(set_data2) 结果: {'a', 'e', 'b', 'd'} |
symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。 | set_data = {'a','b','c'} set_data2 = {'c','d','e'} set_data.symmetric_difference_update(set_data2) 结果: {'e', 'b', 'a', 'd'} |
union() | 返回两个集合的并集 | set_data = {'a','b','c'} set_data2 = {'c','d','e'} set_data.union(set_data2) 结果:{'c', 'd', 'b', 'a', 'e'} |
update(x) | 给集合添加元素 | set_data = {'a','b','c'} set_data.update('d') 结果: {'a', 'b', 'd', 'c'} |
数据类型转换
数据类型的转换,一般情况下你只需要将数据类型作为函数名即可
Python 数据类型转换可以分为两种:
- 隐式类型转换 - 自动完成
- 显式类型转换 - 需要使用类型函数来转换
隐式类型转换
num_int = 123
num_float = 1.23
num_new = num_int + num_float
print(type(num_int)) # <class 'int'>
print(type(num_float)) # <class 'float'>
print(type(num_new)) # <class 'float'>
方法 | 描述 | 用法 |
---|---|---|
int(x) | 将x转换为一个整数 | int_num = int(3.14) 结果: 3 |
float(x) | 将x转换到一个浮点数 | float_num = float(3) 结果: 3.0 |
complex(real [,imag]) | 创建一个复数 | result = complex(1,2) 结果: (1+2j) |
str(x) | 将对象 x 转换为字符串 | str(3.14) |
repr(x) | 将对象 x 转换为表达式字符串 | dict = {'runoob': 'runoob.com', 'google': 'google.com'}; type(repr(dict)) 结果: <class 'str'> |
eval(str) | 用来计算在字符串中的有效Python表达式,并返回一个对象 | x = 7 result = eval('3 * x') 结果: 21 |
tuple(s) | 将列表 s 转换为一个元组 | list_data = ['red','green','blue'] tuple_data = tuple(list_data) 结果: ('red', 'green', 'blue') |
list(s) | 将序列 s 转换为一个列表 | tuple_data = ('red', 'green', 'blue') list_data = list(tuple_data) 结果: ['red', 'green', 'blue'] |
set(s) | 转换为可变集合 | list_data = ['red','green','blue'] set_data = set(list_data) 结果: {'blue', 'red', 'green'} |
dict(**kwarg) | 创建一个字典。d 必须是一个 (key, value)元组序列。 | dict_data = dict(a = 'a',b = 'b',c = 'c'); 结果: {'a': 'a', 'b': 'b', 'c': 'c'} |
frozenset(s) | 转换为不可变集合 | result = frozenset(range(10)) 结果: frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) |
chr(s) | 将一个整数转换为一个字符 | chr(49) 结果: 1 |
ord(s) | 将一个字符转换为它的整数值 | ord('1') 结果: 49 |
hex(s) | 将一个整数转换为一个十六进制字符串 | hex(255) 结果: 0xff |
oct(s) | 将一个整数转换为一个八进制字符串 | oct(10) 结果: 0o12 |
type(x) | 获取类型 | type(int(3.14)) 结果: <class 'int'> |
isinstance(对比的数据,目标类型) | 类型比较 | dict_data = {'name':'a','address':'b'} isinstance(dict_data,dict) 结果: True |
not isinstance(对比的数据,目标类型) | 类型比较 取反 | dict_data = {'name':'a','address':'b'} not isinstance(dict_data,int) 结果: True |
显式类型转换
int()
强制转换为整型:
x = int(1)
y = int(3.14)
z = int('3')
print(type(x), x) # <class 'int'> 1
print(type(y), y) # <class 'int'> 3
print(type(z), z) # <class 'int'> 3
float()
强制转换为浮点型:
x = float(1)
y = float(2.8)
z = float('3')
w = float('4.2')
print(type(x), x) # <class 'float'> 1.0
print(type(y), y) # <class 'float'> 2.8
print(type(z), z) # <class 'float'> 3.0
print(type(w), w) # <class 'float'> 4.2
str()
强制转换为字符串类型:
x = str('s1')
y = str('2')
z = str('3.14')
print(type(x), x) # <class 'str'> s1
print(type(y), y) # <class 'str'> 2
print(type(z), z) # <class 'str'> 3.14
运算符
赋值运算符
运算符 | 描述 | 举例 |
---|---|---|
= | 等于运算符 | c = a + b |
+= | 加法运算符 | c += a -> c = c + a |
-= | 减法运算符 | c -= a -> c = c - a |
*= | 乘法运算符 | c *= a -> c = c * a |
/= | 除法运算符 | c /= a -> c = c / a |
%= | 取模运算符 | c %= a -> c = c % a |
**= | 幂运算符 | c **= a -> c = c ** a |
//= | 整除运算符 | c //= a -> c = c // a |
比较运算符
运算符 | 描述 | 举例 |
---|---|---|
== | 判断是否等于 | a == b |
!= | 判断是否不等于 | a != b |
> | 判断是否大于 | a > b |
< | 判断是否小于 | a < b |
>= | 判断是否大于等于 | a >= b |
<= | 判断是否小于等于 | a <= b |
<> | 判断是否不等于,python3里已经废弃 | a <> b |
身份运算符
运算符 | 描述 | 举例 |
---|---|---|
is | 判断两个对象存储单元是否相同 | a is b |
is not | 判断两个对象存储单元是否不同 | a is not b |
流程控制与函数
流程控制
if elif else 语句
num_01 = 10
if num_01 > 10:
print('变量num_01大于10,值为:%s' % num_01)
elif num_01 < 10:
print('变量num_01小于10,值为:%s' % num_01)
else:
print('变量num_01等于10,值为:%s' % num_01)
match...case 语句
Python 3.10 增加了 match...case 的条件判断,不需要再使用一连串的 if-else 来判断了。
match 后的对象会依次与 case 后的内容进行匹配,如果匹配成功,则执行匹配到的表达式,否则直接跳过,可以使用 |
将多个字面量组合起来表示或,可以匹配一切。
基础使用
status = 401
match status:
case 400:
print('匹配400')
case 401:
print('匹配401')
|
使用
status = 401
match status:
case 400 | 401:
print('匹配400或者401')
case 402:
print('匹配402')
解元组包进行匹配
tuple_data = (10,20)
match tuple_data:
# 当元组的数据为(0,0) 匹配通过
case (0,0):
print('匹配0,0')
# 当元组的长度只有两位的时候,匹配通过
case (x,y):
print(x,y)
# 当元组的第二个参数为20的时候,匹配通过
case (x,20):
print('匹配参数2')
# 当元组的数据为(10,20) 匹配通过
case (10,20):
print('匹配10,20')
枚举
from enum import Enum
class Color(Enum):
RED = 0
GREEN = 1
BLUE = 2
color = Color.RED
match color:
case Color.RED:
print("I see red!")
case Color.GREEN:
print("Grass is green")
case Color.BLUE:
print("I'm feeling the blues :(")