首页 / PYTHON / Python基础(1)
Python基础(1)
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了Python基础(1),小编现在分享给大家,供广大互联网技能从业者学习和参考。文章包含16472字,纯文字阅读大概需要24分钟。
内容图文
![Python基础(1)](/upload/InfoBanner/zyjiaocheng/1110/d00a4e9971b94510a793daee8c86418d.jpg)
Python 简介
Python 定义
是一个免费、开源、跨平台、动态、面向对象的编程语言。
Python程序的执行方式
交互式
在命令行输入指令,回车即可得到结果。
- 打开终端
- 进入交互式:python3
- 编写代码:print(“hello world”)
- 离开交互式:exit()
文件式
将指令编写到.py文件,可以重复运行程序。
- 编写文件。
- 打开终端
- 进入程序所在目录:cd 目录
- 执行程序: python3 文件名
执行过程
计算机只能识别机器码(1010),不能识别源代码(python)。
- 由源代码转变成机器码的过程分成两类:编译和解释。
- 编译:在程序运行之前,通过编译器将源代码变成机器码,例如:C语言。
-- 优点:运行速度快
-- 缺点:开发效率低,不能跨平台。
- 解释:在程序运行之时,通过解释器对程序逐行翻译,然后执行。例如Javascript
-- 优点:开发效率高,可以跨平台;
-- 缺点:运行速度慢。
- python是解释型语言,但为了提高运行速度,使用了一种编译的方法。编译之后得到pyc文件,存储了字节码(特定于Python的表现形式,不是机器码)。
源代码 -- 编译 --> 字节码 -- 解释 --> 机器码
|————1次———|
解释器类型
- CPython(C语言开发)
- Jython (java开发)
- IronPython (.net开发)
- 移动到本行开头:home键
- 移动到本行末尾:end键盘
- 注释代码:ctrl + /
- 复制行:ctrl +d
- 选择列:鼠标左键 + alt
- 移动行:shift + alt + 上下箭头
- 智能提示:Ctrl + Space
数据基本运算
pycharm常用快捷键
注释
给人看的,通常是对代码的描述信息。
- 单行注释:以#号开头。
- 多行注释:三引号开头,三引号结尾。
函数
表示一个功能,函数定义者是提供功能的人,函数调用者是使用功能的人。
例如:
- print(数据) 作用:将括号中的内容显示在控制台中
- 变量 = input(“需要显示的内容”) 作用:将用户输入的内容赋值给变量
- Round(数字),四舍六入(不考虑正负号),五取偶
- 定义:关联一个对象的标识符。三个特征:id、type、value
- 命名:必须是字母或下划线开头,后跟字母、数字、下划线。
变量
不能使用关键字(蓝色),否则发生语法错误:SyntaxError: invalid syntax。
- 建议命名:字母小写,多个单词以下划线隔开。变量名应既简短又具有描述性。慎用大写字母I 和 O,容易被看成数字1和0。
class_name
- 赋值:创建一个变量或改变一个变量关联的数据。
- 语法:变量名 = 数据
变量名1 = 变量名2 = 数据
变量名1, 变量名2, = 数据1, 数据2
>>> a=10000
>>> b=10000
>>> a is b
False
>>> a=10000
>>> b=a
>>> a is b
True
del 语句
- 语法:
del 变量名1, 变量名2
- 作用:
用于删除变量,同时解除与对象的关联.如果可能则释放对象。
- 自动化内存管理的(数据对象的)引用计数:
每个对象记录被变量绑定(引用)的数量,当为0时被销毁。
核心数据类型
- 在python中变量没有类型,但关联的对象有类型。
- 通过type函数可查看。
- 表示不存在的特殊对象。
- 作用:占位和解除与对象的关联。
- 表示整数,包含正数、负数、0。
空值对象 None
整形int
如: -5, 100, 0
- 字面值:
十进制:5
二进制:0b开头,后跟1或者0
八进制:0o开头,后跟0~7
十六进制:0x开头,后跟0~9,A~F,a~f(数据的内存地址是以16进制数表示的)
- 小整数对象池:CPython 中整数 -5 至 256,永远存在小整数对象池中,不会被释放并可重复使用。
- 表示小数,包含正数、负数,0.0)。
- 字面值:
浮点型float
小数:1.0 2.5
科学计数法:e/E (正负号) 指数
1.23e-2 (等同于0.0123)
1.23456e5(等同于123456.0)
字符串str
是用来记录文本信息(文字信息)。
字面值:双引号
str.upper():将字符串改为全部大写
str.lower():将字符串改为全部小写
str.title():将字符串中每个单词的首字母都改为大写
str.rstrip():删除右边空白
str.lstrip():删除左边空白
str.strip():删除两端空白
复数complex
由实部和虚部组成的数字。
虚部是以j或J结尾。
字面值: 1j 1+1j 1-1j
布尔bool
用来表示真和假的类型
True 表示真(条件满足或成立),本质是1
False 表示假(条件不满足或不成立),本质是0,” ”
数据类型转换
- 转换为整形: int(数据)
- 转换为浮点型:float(数据)
- 转换为字符串:str(数据)
- 转换为布尔:bool(数据)
结果为False:bool(0) bool(0.0) bool(None)
- 混合类型自动升级:
4/2 返回的结果是 2.0
1 + 3.0 返回结果是: 4.0
运算符
算术运算符
+ 加法
- 减法
* 乘法
/ 除法:结果为浮点数
// 地板除:除的结果去掉小数部分(商为负数时去掉小数部分再 -1)向下圆整
% 求余
** 幂运算
优先级从高到低: ()
**
* / % //
+ -
增强运算符
y += x 等同于 y = y + x
y -= x 等同于 y = y - x
y *= x 等同于 y = y * x
y /= x 等同于 y = y / x
y //= x 等同于 y = y // x
y %= x 等同于 y = y % x
y **= x 等同于 y = y ** x
比较运算符
< 小于
<= 小于等于
> 大于
>= 大于等于
== 等于
!= 不等于
返回布尔类型的值
比较运算的数学表示方式:0 <= x <= 100
逻辑运算符
与and
表示并且的关系,一假俱假。
示例:
True and True # True
True and False # False
False and True # False
False and False # False
或or
表示或者的关系,一真俱真
示例:
True or True # True
True or False # True
False or True # True
False or False # False
非 not
表示取反
例如:
not True # 返回False
not False # 返回True
短路运算
一但结果确定,后面的语句将不再执行。
身份运算符
语法:
x is y
x is not y
作用:
is 用于判断两个对象是否是同一个对象,是时返回True,否则返回False。
is not 的作用与is相反
优先级
高到低:
算数运算符
比较运算符
身份运算符
逻辑运算符
语句
行
- 物理行:程序员编写代码的行。
- 逻辑行:python解释器需要执行的指令。
- 建议一个逻辑行在一个物理行上。
- 如果一个物理行中使用多个逻辑行,需要 使用分号;隔开 。
5. 如果逻辑行过长,可以使用隐式换行或显式换行。
隐式换行:所有括号的内容换行,称为隐式换行
括号包括: () [] {} 三种
显式换行:通过折行符 \ (反斜杠)n换行,必须放在一行的末尾,目的是告诉解释器,下一行也是本行的语句。
pass 语句
通常用来填充语法空白。
选择语句
If elif else 语句
- 作用:
让程序根据条件选择性的执行语句。
- 语法:
if 条件1:
语句块1
elif 条件2:
语句块2
else:
语句块3
- 说明:
if,elif,else所对应的条件是彼此互斥的。:不能省略
elif 子句可以有0个或多个。
else 子句可以有0个或1个,且只能放在if语句的最后。
if 语句的真值表达式
if 100:
print("真值")
等同于
if bool(100):
print("真值")
条件表达式
语法:变量 = 结果1 if 条件 else 结果2
作用:根据条件(True/False) 来决定返回结果1还是结果2。
循环语句
while语句
- 作用:
可以让一段代码满足条件,重复执行。
- 语法:
while 条件:
满足条件执行的语句
else:
不满足条件执行的语句(可以看循环是从条件离开的还是从循环体离开的)
- 说明:
else子句可以省略。
在循环体内用break终止循环时,else子句不执行。
for 语句
- 作用:
用来遍历可迭代对象的数据元素。适用于预定次数的循环
可迭代对象是指能依次获取数据元素的对象,例如:容器类型。
- 语法:
for 变量列表 in 可迭代对象:
语句块1
else:
语句块2
- 说明:
else子句可以省略。
在循环体内用break终止循环时,else子句不执行。
#示例
while True:
循环体(如需要多次输入,input)
if 条件:
break # 退出循环
range 函数
- 作用:用于生成容器的索引作为for循环遍历的可迭代对象
用来创建一个生成一系列整数的可迭代对象(也叫整数序列生成器)。
- 语法:
range(开始点,结束点,间隔)
- 说明:
函数返回的可迭代对象可以用for取出其中的元素
返回的数字不包含结束点
开始点默认为0
间隔默认值为1
跳转语句
break 语句
- 跳出循环体,后面的代码不再执行。
- 可以让while语句的else部分不执行。
continue 语句
跳过本次,继续下次循环。
for 循环嵌套
1.end=""不换行,print()换行
2.外层循环做一次,内层循环全做完
3.外层循环控制行,内层循环控制列(控制一维,平面上的问题)
4.先写内再写外
容器类型
通用操作
数学运算符
- +:用于拼接两个容器
- +=:用原容器与右侧容器拼接,并重新绑定变量
- *:重复生成容器元素
- *=:用原容器生成重复元素, 并重新绑定变量
- < <= > >= == !=:依次比较两个容器中元素,一但不同则返回比较结果。
- 语法:
成员运算符
数据 in 序列
数据 not in 序列
- 作用:
如果在指定的序列中找到值,返回bool类型。
索引index
- 作用:访问容器元素,定位 单个 元素
- 语法:容器[index]
- 说明:索引必须是整数,注意 索引越界
正向索引从0开始,第二个索引为1,最后一个为len(s)-1。
反向索引从-1开始,-1代表最后一个,-2代表倒数第二个,以此类推,第一个是-len(s)。
切片slice
- 作用:
从容器中取出相应的元素重新组成一个容器(在赋值号 ”=”右侧时),在赋值号(=)左侧时起定位作用定位多个元素。
- 语法:
容器[(开始索引):(结束索引)(:(步长))]
- 说明:
小括号()括起的部分代表可省略
结束索引不包含该位置元素
步长是切片每次获取完当前元素后移动的偏移量
4. 切片:定位多个元素
message = "我叫齐天大圣。"
print(message[2:6])# 齐天大圣
print(message[2:6:2])# 齐大
# 开始索引,默认从头开始。
print(message[:6])# 我叫齐天大圣
# 结束索引,默认到末尾。
print(message[2:])# 齐天大圣。
# 正向获取
print(message[:])# 我叫齐天大圣。
# 反向获取
print(message[::-1])# 。圣大天齐叫我
print(message[-3:-6:-1])# 大天齐
# 可以同时使用反向与正向索引
print(message[-3:1:-1])# 大天齐
print(message[3:1])# 空
print(message[3:1:-1])# 天齐
print(message[1:1])# 空
print(message[-2:1])# 空
print(message[1:500])# 叫齐天大圣。
内建函数
- len(x) 返回序列的长度
- max(x) 返回序列的最大值元素
- min(x) 返回序列的最小值元素
- sum(x) 返回序列中所有元素的和(元素必须是数值类型)
字符串 str
定义
由一系列 字符序列 组成的 不可变 容器,存储的是字符的编码值。
编码
- 字节byte:计算机最小存储单位,等于8 位bit.
- 字符:单个的数字,字母与符号。
- 字符集(码表):存储字符与二进制序列的对应关系。
- 编码:将字符转换为对应的二进制序列的过程。ord(字符串)-->数字
- 解码:将二进制序列转换为对应的字符的过程。chr(数字)-->字符串
- 编码方式:
--ASCII编码:包含英文、数字等字符,每个字符1个字节。
--GBK编码:兼容ASCII编码,包含21003个中文;英文1个字节,汉字2个字节。
--Unicode字符集:国际统一编码,旧字符集每个字符2字节,新字符集4字节。
-- UTF-8编码:Unicode的存储与传输方式,英文1字节,中文3字节。
相关函数
- ord(字符串):返回该字符串的Unicode码。
- chr(整数):返回该整数对应的字符串。
字面值
可见即所得。’’ “” ‘’’‘’’ “”””””
单引和双引号的区别
- 单引号内的双引号不算结束符 #同种引号不能嵌套使用
- 双引号内的单引号不算结束符
- 换行会自动转换为换行符\n
- 三引号内可以包含单引号和双引号
- 作为文档字符串
- 改变字符的原始含义。
三引号作用
转义字符
\’ \” \”””
\n 换行符输出
\\
\t 制表符,输出是缩进
\0 空字符
- 原始字符串: 取消所有转义符。
a = r”C:\newfile\test.py”
字符串格式化
- 定义:
生成一定格式的字符串。 (用于在字符串中插入变量的操作)
- 语法:
“%s---%d---%f” % (变量1,变量2,变量3)
"我的名字是%s,年龄是%d" % (name, age)
- 类型码:
%s 字符串 %d整数 %f 浮点数(%.1f %.2f)
列表 list
定义
由一系列 变量序列 组成的 可变 容器。
基础操作
- 创建列表:
列表名 = []
>>> list01=[100,200,300]
>>> list02=list01
>>> list01==list02
True
>>> list01 is list02
True
#注意:跟小整数对象池的区别
>>> list01=[100,200]
>>> list02=[100,200]
>>> list01==list02
True
>>> list01 is list02
False
列表名 = list(可迭代对象) #list(range(5))
>>> print(list(range(5)))
[0, 1, 2, 3, 4]
>>> print(list("abcde"))
[‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]
>>> print(list("看书,跑步"))
[‘看‘, ‘书‘, ‘,‘, ‘跑‘, ‘步‘]
- 增:添加元素:
列表名.append(元素) --末尾追加
列表.insert(索引,元素) --插入
- 改:定位赋值
索引
list[index]=要改成的数据
切片( 赋值号左边,不产生新列表 )
list[:2]=[数据1,数据2]
- 查:list.index(obj) #返回obj这个元素在列表list中首次出现位置的索引值
遍历列表: #list.count(obj) #统计obj这个元素在列表list中出现的次数
正向:
for 变量名 in 列表名:
变量名就是元素
反向:
for 索引名 in range(len(列表名)-1,-1,-1):
列表名[索引名]就是元素
- 删: 依次删除列表元素时要倒着从后往前删,range(len(列表名)-1,-1,-1)
列表名.remove(元素a) ,只移除第一次出现的‘元素a’,返回值为none
#list.pop() 移除列表最后一个元素(返回值为被删除的元素,适用于从列表中移除后还需继续使用,括号中填上index可以删除任意位置元素)
del 列表名[索引或切片]
6.列表排序:
list.sort():按照首字母a-z或者数字0-9等规则排序,不能恢复原顺序,反向排序括号中输入参数reverse=true
sorted(list):按照首字母a-z或者数字0-9等规则排序,不改变列表原顺序
list.reverse():将列表中元素倒序排列,再使用一次.reverse()即可恢复
深拷贝和浅拷贝
浅拷贝:复制过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程。
list02=list01[:](切片在赋值号右边)
>>> list01=[100,[200,300]]
>>> list02=list01[:] #切片产生的新列表只复制(重新生成)了list01的第一层
>>> list01[1][0]=500
>>> print(list02[1][0])
500
深拷贝:复制整个依懒的变量。
Import copy
list02=copy.deepcopy(list01)
https://www.jianshu.com/p/03dce38cc97e
列表VS字符串
7.05exercise08经典案例
- 列表和字符串都是序列,元素之间有先后顺序关系。
- 字符串是不可变的序列,列表是可变的序列。
- 字符串中每个元素只能存储字符,而列表可以存储任意类型。
- 列表和字符串都是可迭代对象。
- 函数:
将列表中多个字符串类型元素拼接为一个字符串。
result = "连接符".join(list) #list-->str
>>> list01=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
>>> strings="".join(list01)
>>> print(strings)
abcde
>>> print(",".join(list01))
a,b,c,d,e
将一个字符串拆分为多个。
list = “a-b-c-d”.split(“ - ”) #str-→list
>>> string="www.baidu.com"
>>> list01=string.split(".")
>>> print(list01)
[‘www‘, ‘baidu‘, ‘com‘]
列表推导式
- 定义:
使用简易方法,将可迭代对象转换为列表。
- 语法:
变量 = [变量1(可迭代对象中的元素)的表达式 for 变量1 in 可迭代对象]
变量 = [变量1(可迭代对象中的元素)的表达式 for 变量1 in 可迭代对象 if 条件]
- 说明:
如果if真值表达式的布尔值为False,则可迭代对象生成的数据将被丢弃。
- 适用性:将可迭代对象中的所有元素(或者满足一定条件的部分元素)根据一定规则(运算表达式)存入列表中。
list01 = [5,15,55,6,6,7]
需求1:将lie01中所有数据+1再存储另外一个列表
# list02 = []
# for item in list01:
# list02.append(item + 1)
list02 = [item + 1 for item in list01]
需求2:将lie01中大于10的数据,+1再存储另外一个列表
#list02 = []
#for item in list01:
# if item > 10:
# list02.append(item + 1)
list02 = [item + 1 for item in list01 if item > 10]
列表推导式嵌套
- 语法:
变量 = [表达式 for 变量1 in 可迭代对象1 for 变量2 in可迭代对象2]
- 传统写法:
result = []
for r in ["a", "b", "c"]:
for c in ["A", "B", "C"]:
result.append(r + c)
- 推导式写法:
result = [r + c for r in list01 for c in list02]
元组 tuple
定义
- 由一系列变量序列组成的不可变容器。
- 不可变是指一但创建,不可以再添加/删除/修改元素。
>>> name="lzmly"
>>> t01=("qtx",name)
>>> name="mm"
>>> print(t01)
(‘qtx‘, ‘lzmly‘) →内存没变,结果也没变是因为变量指向的对象是字符串(不可变容器)
>>> list_names=["lzmly","mm"]
>>> tuple01=("qtx",list_names)
>>> list_names.append("zx")
>>> print(tuple01)
(‘qtx‘, [‘lzmly‘, ‘mm‘, ‘zx‘]) →内存没变,依然是两个变量(元素),变的是变量指向的对象(列表)
基础操作
- 创建空元组: #元组一旦创建就不可添加/删除/修改元素
元组名 = ()
元组名 = tuple()
- 创建非空元组:
元组名 = (20,) #元组只有一个对象时要加 ,
元组名 = (1, 2, 3)
元组名 = 100,200,300
元组名 = tuple(可迭代对象)
>>> list01 = ["a","b"]
>>> tuple02 = tuple(list01)
>>> tuple02
(‘a‘, ‘b‘)
>>> print(tuple("看书,跑步,钢琴"))
(‘看‘, ‘书‘, ‘,‘, ‘跑‘, ‘步‘, ‘,‘, ‘钢‘, ‘琴‘)
- 查:获取元素:
索引(tuple[索引])、切片(tuple[::])
>>> tuple03 = ("a","b","c","d")
>>> print(tuple03[2])
c
>>> tuple03 = ("a","b","c","d")
>>> print(tuple03[1:3])
(‘b‘, ‘c‘)
- 遍历元组:
正向:
for 变量名 in 元组名:
变量名就是元素
反向:
for 索引名 in range(len(元组名)-1,-1,-1):
元祖名[索引名]就是元素
作用
- 元组与列表都可以存储一系列变量,由于列表会预留内存空间,所以可以增加元素。
- 元组会按需分配内存,所以如果变量数量固定,建议使用元组,因为占用空间更小。
- 应用:
变量交换的本质就是创建元组:x, y = (y, x) 。可通过元组给多个变量赋值
格式化字符串的本质就是创建元组:"姓名:%s, 年龄:%d" % ("tarena", 15)
字典 dict
定义
- 由一系列键值对散列组成的可变容器。#可变是指键对应的值可变,键不可变
- 散列:对键进行哈希运算,确定在内存中的存储位置,每条数据存储无先后顺序。内存图
- 键(可看做变量名)必须唯一且不可变(字符串/数字/元组),唯一是不重复,不可变指的是可哈希,即内存地址唯一且不可变。
- 创建字典:
基础操作
字典名 = {键1:值1,键2:值2}
字典名 = dict (可迭代对象) 需要成对,用括号分开
>>> list01 = [["a","b"],("c","d")]
>>> dict02 = dict(list01)
>>> print(dict02)
{‘a‘: ‘b‘, ‘c‘: ‘d‘}
- 添加/修改元素:
语法:
字典名[键] = 数据 #键相当于index的功能
说明:
键不存在,创建记录。
键存在,修改映射关系。
- 获取元素:
变量 = 字典名[键] # 没有该键则错误,所以查找前,一定通过in判断
用键直接获取的是键对应的值
dict02={‘a‘: ‘b‘, ‘c‘: ‘d‘}
>>> m=dict02["c"]
>>> print(m)
d
- 遍历字典:
for 键名 in 字典名:
字典名[键名] -->值
示例:
dict02 = {"qtx":18,"ls":20,"ww":23}
for key in dict02:
print(key) #qtx ls ww -->键
print(dict02[key]) #18 20 23 -->值
for 键名,值名 in 字典名.items():
语句
示例:
for key in dict02.items():
print(key) #(‘qtx‘, 18) (‘ls‘, 20) (‘ww‘, 23) -->一系列(键,值)元组
print(key[0]) #qtx ls ww -->键
print(key[1]) #18 20 23 -->值
for key,value in dict02.items():
print(key,value) #qtx 18 ls 20 ww 23 -->键 值
print(key) #qtx ls ww -->键
print(value) #18 20 23 -->值
for value in dict02.values():
print(value) #18 20 23 -->值
for key in dict02.keys():
print(key) #qtx ls ww -->键
- 删除元素:
del 字典名[键] #键值一起删除了
字典推导式
- 定义:
使用简易方法,将可迭代对象转换为字典。
- 语法:
{键:值 for 变量 in 可迭代对象}
# 需求: key :0---9,value :键的平方
dict01 = {}
for item in range(10):
dict01[item] = item ** 2
dict02 = {item: item ** 2 for item in range(10)}
{键:值 for 变量 in 可迭代对象 if 条件}
# 需求:key:range(10) 大于5的数,value :键的平方
dict01 = {}
for item in range(10):
if item > 5:
dict01[item] = item ** 2
dict02 = {item: item ** 2 for item in range(10) if item > 5}
字典 VS 列表
- 都是可变容器。
- 获取元素方式不同,列表用索引,字典用键。
- 字典的插入,删除,修改的速度快于列表。
-
列表的存储是有序的,字典的存储是无序的。
- 由一系列不重复的(哈希code确定了地址)不可变类型变量组成的可变(增删)散列(不能单独取值)容器。
集合 set
定义
集合元素类型不可变:s=set();s.add([1,2]) #unhashable type: ‘list‘
- 相当于只有键没有值的字典(键则是集合的数据)。
- 用途:将其他具有重复元素的容器转换成集合(去重复)set01 = set("abcabc")
- 创建空集合:
基础操作
集合名 = set() #只有这一种方式
- 创建具有默认值集合:
集合名 = {1, 2, 3}
集合名 = set(可迭代对象)
- 添加元素:
集合名.add(元素)
- 删除元素:
集合名.discard(元素) #如果没有该元素则报错
集合名.remove(元素)
运算
- 交集&:返回共同元素。
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 & s2 # {2, 3}
- 并集:返回所有不重复元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 | s2 # {1, 2, 3, 4}
- 差集-:返回只属于其中之一的元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 - s2 # {1} 属于s1但不属于s2
补集^:返回不同的的元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 ^ s2 # {1, 4} 等同于(s1-s2 | s2-s1)
- 子集<:判断一个集合的所有元素是否完全在另一个集合中
- 超集>:判断一个集合是否具有另一个集合的所有元素
s1 = {1, 2, 3}
s2 = {2, 3}
s2 < s1 # True #包含于
s1 > s2 # True #包含
- 相同或不同== !=:判断集合中的所有元素是否和另一个集合相同。
s1 = {1, 2, 3}
s2 = {3, 2, 1}
s1 == s2 # True
s1 is s2 #False
子集或相同,超集或相同 <= >=
集合推导式
- 定义:
使用简易方法,将可迭代对象转换为集合。
- 语法:
{表达式 for 变量 in 可迭代对象}
{表达式 for 变量 in 可迭代对象 if 条件}
固定集合 frozenset
定义
不可变的集合。
作用
固定集合可以作为字典的键,还可以作为集合的值。主要作用:与其他容器互相转换
基础操作
创建固定集合:frozenset(可迭代对象)
运算
等同于set
函数 function
pycharm相关设置
- “代码自动完成”时间延时设置
File -> Settings -> Editor -> General -> Code Completion -> Autopopup in (ms):0
- 快捷键:
Ctrl + P 参数信息(在方法中调用参数)提示输入什么参数
Ctrl + Q 快速查看文档(对函数形参和返回值的描述)
Ctrl + Alt + M 提取方法
定义
- 用于封装一个特定的功能,表示一个(只做计算或者逻辑处理)功能或者行为。
- 函数是可以重复执行的语句块, 可以重复调用。
- 函数相当于是自己编一个数学公式去完成计算
- 函数名称的命名应该表述其作用,动词+名词
作用
提高代码的可重用性和可维护性(代码层次结构更清晰)。
定义函数
- 语法:
def 函数名(形式参数):
函数体
- 说明:
def 关键字:全称是define,意为”定义”。
函数名:对函数体中语句的描述,命名规则与变量名相同。
形式参数:方法定义者要求调用者提供的信息。
函数体:完成该功能的语句。尽量小于10行
- 函数的第一行语句建议使用文档字符串描述函数的功能与参数。
- 语法:函数名(实际参数)
- 说明:根据形参传递内容。
- 定义:
调用函数
返回值
方法定义者告诉调用者的结果。
- 语法:
return 数据(或变量/表达式)
- 说明:
return后没有语句,相当于返回 None。
函数体没有return,相当于返回None。
返回值可能有多个,必须返回一个类型的值
可变/不可变类型实参在传参时的区别
- 不可变类型参数有:
数值型(整数,浮点数,复数)
布尔值bool
None 空值
字符串str
元组tuple
固定集合frozenset
- 可变类型参数有:
列表 list
字典 dict
集合 set
- 传参说明:
不可变类型的数据传参时,函数调用后不会改变原实参数据的值。
可变类型的数据传参时,函数调用后可以(切片定位时)改变原数据。day08 demo01
函数体中,“变量[ ]”的存在可改变可变对象
函数参数
实参传递方式argument
位置传参
定义:实参与形参的位置依次对应。
序列传参
定义:实参用*将序列拆解后与形参的位置依次对应。
关键字传参
定义:实参根据形参的名字进行对应,调用函数时直接给形参赋值。
字典关键字传参
- 定义:实参用**将字典拆解后键与形参的名字进行对应,将值传给形参。
- 作用:配合形参的缺省参数,可以使调用者随意传参。
def fun01(a, b, c):
print(a)
print(b)
print(c)
# 1. 位置实参 : 实参根据位置与形参进行对应
# positional argument
fun01(1, 2, 3) #1 2 3
# 2. 序列实参 : 使用星号将序列中的元素拆开,与形参进行对应 .
# 序列 : 字符串 列表 元组
list01 = ["aaa", "bb", "cc"]
fun01(*list01) # aaa bb cc
# 3. 关键字实参:实参根据名称与形参进行对应
fun01(b=2, a=1, c=3) # 1 2 3
# 4. 字典实参:使用双星号将字典中的元素拆开 , 根据键形参进行对应 , 传递值 ..
dict01 = {"c": 33, "a": 11, "b": 22}
fun01(**dict01) #11 22 33
形参定义方式parameter
默认参数
- 语法:
def 函数名(形参名1=默认实参1, 形参名2=默认实参2, ...):
函数体
- 说明:
缺省参数必须自右至左依次存在,如果一个参数有缺省参数,则其右侧的所有参数都必须有缺省参数。
缺省参数可以有0个或多个,甚至全部都有缺省参数。
位置形参
语法:
def 函数名(形参名1, 形参名2, ...):
函数体
星号元组形参
- 语法:
def 函数名(*元组形参名):
函数体
- 作用:
收集多余的位置传参。
- 说明:
一般命名为‘args‘
形参列表中最多只能有一个
命名关键字形参
- 语法:
def 函数名(*, 命名关键字形参1, 命名关键字形参2, ...):
函数体
def 函数名(*args, 命名关键字形参1, 命名关键字形参2, ...):
函数体
- 作用:
强制实参使用关键字传参
双星号字典形参
- 语法:
def 函数名(**字典形参名):
函数体
- 作用:
收集多余的关键字传参
- 说明:
一般命名为‘kwargs‘
形参列表中最多只能有一个
参数自左至右的顺序
位置形参 --> 星号元组形参 --> 命名关键字形参 --> 双星号字典形参
# 1. 默认形参:实参可以不传递数据(从右向左依次存在)
def fun01(a=0, b="bb", c=1.5):
print(a)
print(b)
print(c)
fun01()
fun01(1, "b")
# 关键实参 + 默认形参:调用者可以随意指定参数进行传递
fun01(b="bbbbb")
# 2. 星号元组形参:让位置实参的数量无限
def fun02(p1, p2, *args):
print(args)
fun02(1, 2) #()
fun02(1, 2, 3)#(3,)
fun02(1, 2, 3, 4, 5)#(3,4,5)
# 3. 命名关键字形参:传递的实参必须是关键字实参。
# 写法1:星号元组形参以后的参数是命名关键字形参
# p1 p2
def fun03(*args, p1="", p2):
print(args)
print(p1)
print(p2)
fun03(2, 2, p1=111, p2=222)
fun03(p1=111, p2=222)
fun03(p2=222)
# 案例:
# def print(*args, sep=‘ ‘, end=‘\n‘, file=None):
# 1---fff---3.5---4---55---6---67 ok
print(1, "fff", 3.5, 4, 55, 6, 67, sep="---", end=" ")
print("ok")
# 写法2:星号以后的位置形参是命名关键字形参
def fun04(*, p1=0, p2):
print(p1, p2)
fun04(p1=1, p2=2)
fun04(p2=2)
# 4. 双星号字典形参:让关键字实参的数量无限
def fun05(**kwargs):
print(kwargs)
fun05(a=1) # {‘a‘: 1}
fun05(a=1, b=2)
fun05(a=1, b=2, qtx=3) # {‘a‘: 1, ‘b‘: 2, ‘qtx‘: 3}
作用域LEGB
- 作用域:变量起作用的范围。day08.demo02
- Local局部作用域:函数内部。
- Enclosing 外部嵌套作用域:函数嵌套。
- Global全局作用域:模块(.py文件)内部。
- Builtin内置模块作用域:builtins.py文件。
g01 = "悟空"
g02 = "八戒"
g03 = "沙僧"
def fun01():
l01 = 100
print(l01)# 只能在函数内部使用局部变量
print(g01)# 在函数内部可以访问全局变量
# 创建了局部变量g02,覆盖了全局变量g02
g02 = "老朱"
print("fun01---"+g02)
# 声明全局变量g03
global g03
g03 = "老沙"
fun01() #100 悟空 fun01---老朱
print("全局---"+g02) # 全局---八戒
print(g03) #老沙
变量名的查找规则
- 由内到外:L -> E -> G -> B
- 在访问变量时,先查找本地变量,然后是包裹此函数外部的函数内部的变量,之后是全局变量,最后是内置变量。
- 定义在函数内部的变量(形参也是局部变量)
- 只能在函数内部使用
- 调用函数时才被创建,函数结束后自动销毁
- 定义在函数外部,模块内部的变量。
- 在整个模块(py文件)范围内访问(但函数内不能将其直接赋值)。
局部变量
全局变量
# 练习:定义my_print函数,统计该函数调用的次数。
count = 0
def my_print():
global count
count = count + 1
my_print()
my_print()
my_print()
print(count)
global 语句
- 作用:
在函数内部修改全局变量。
在函数内部定义全局变量(全局声明)。
- 语法:
global 变量1, 变量2, …
- 说明
在函数内直接为全局变量赋值,视为创建新的局部变量。
不能先声明局部的变量,再用global声明为全局变量。
nonlocal 语句
- 作用:
在内层函数修改外层嵌套函数内的变量
- 语法
nonlocal 变量名1,变量名2, ...
- 说明
在被嵌套的内函数中进行使用
原文:https://www.cnblogs.com/lennie-luo/p/12903491.html
内容总结
以上是互联网集市为您收集整理的Python基础(1)全部内容,希望文章能够帮你解决Python基础(1)所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错,欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 gblab@vip.qq.com 举报,一经查实,本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。