Python 从入门到放弃之基础

145 阅读19分钟

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判断变量是否在序列中
whileWhile循环语句
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)从指定范围内,按指定基数递增的集合中获取一个随机数,基数默认值为 1import 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是大于1import 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.0import 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)字符串中开头是否包含某个字符,返回boolexample_str = 'aBcDefg'
new_str = example_str.startswith('a')
结果: new_str # True
结果: example_str #aBcDefg
endswith(str)字符串中结尾是否包含某个字符,返回boolexample_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)字符是否在字符串中,存在则返回指定索引,否则返回-1example_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()字符串是否是一个由空格组成,返回boolexample_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,依此类推。

image.png

反向索引

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数据是否包含在数组中,返回boolnum_list = [1,2,3,4,5]
1 in num_list
结果: True
not in数据是否不包含在数组中,返回boolnum_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)统计元组中指定参数的个数,不能为空,不存在则返回0tuple_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)返回指定键的值,如果键不在字典中返回 Nonedict_01 = {'name': 'tony'}
dict_01.get('name1')
结果: None
key in dict如果键在字典dict里返回true,否则返回falsedict_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 :(")

函数

面向对象与异常处理

面向对象

异常处理

模块与文件操作

模块

文件操作

多线程编程

正则表达式