Python笔记——【编程语言】Python基础知识整理_python编程
Python基础目录
一、Python基础语法
版本:Python 3.7
1. 注释方法
单行注释:# 注释内容(快捷键:Ctrl+ /)
多行注释:‘’’ 注释内容 ‘’’ 或 “”“注释内容”“”
2. 关键字
关键字一共33个,False、None和True的首字母大写,其他全部是小写

3. 标识符
1、标识符的命名规则(必须遵守)
由数字、字?、下划线_组成
不能数字开头
不能使?内置关键字
严格区分??写
2、标识符的命名规范(建议遵守)
?名知意
?驼峰:即每个单词?字?都?写,例如: XxxYyyy
?驼峰:第?个(含)以后的单词?字??写,例如: xxxYyy
下划线:例如: xxx_yyy
4. 变量
1、 单个变量赋值
变量名 = 值
2、 多个变量赋值
变量名1,变量名2,变量名3 = 值1,值2,值3
3.、多变量赋相同值
变量名1 = 变量名2 = 变量名3 = 值
5. 数据类型
(1)整型
1、整型 :int
2、创建整型 :变量名 = 整数
创建空整型:
变量名 = int()
(2)浮点型
1、浮点型 :float
2、创建浮点型 :变量名 = 浮点数
创建空浮点型:
变量名 = float()
(3)布尔型
1、布尔型 :bool
2、创建布尔型 :变量名 = True 或 变量名 = False
创建空布尔型:
变量名 = bool()
(4)字符串
1、字符串 :str
2、创建字符串
单引号:‘字符串’、“字符串”
三引号(支持换行):‘’‘字符串’‘’、“”“字符串”“”
创建空字符串:
‘’或str()
3、常用操作
查找
下标记(computer assigns an incremental index starting index from 0 to each element in the data sequence):
字符串序列[下标记位置]切片:
字符串序列[开始位置下标:结束位置下标:step]
- 结束位置索引:值为-1时表示倒数第一个元素
- 步长设置:默认值为1,默认情况下每隔一个元素进行操作;支持正负数值皆可应用
- 最大允许范围:最大操作范围限定至当前索引值的前一位
结束位置下标:-1代表倒数第一个数据
步长:选取间隔,默认为1,正负数均可,-1代表从结束位置开始往前取
最多取到结束位置下标的前一个数据
方法 :
- find 的作用是查找某个特定字符串是否存在于给定字符串中,并根据匹配结果返回相应信息
字符串序列.find(串, 开始位置下标, 结束位置下标)的语法定义为:若目标字符串存在,则给出其起始位置的下标;若不存在则返回-1- rfind 和 find 功能一致 但其查找方向是从右往左进行
字符串序列.rfind(串, 开始位置下标, 结束位置下标)的语法定义与find方法相同- index 和 find 功能基本一致 但区别在于当无法找到目标时该方法会抛出异常异常信息
字符串序列.index(串, 开始位置下标, 结束位置下标)的语法定义与find方法一致- rindex 类似于 index 方法 但在搜索方向上采用了从右往左的方式
字符串序列.rindex(串, 开始位置下标, 结束位置下标)的语法定义与index方法相同- count 方法用于统计特定子字符串在整个主字符串中的出现次数
- 其语法定义为:
字符串序列.count(串, 开始位置下标, 结束位置下标)
find() 功能:用于查找特定子串是否存在,并返回其起始索引值;若未找到,则返回-1 语法:字符串序列中的find方法接受三个参数——目标子串、起始索引和结束索引
**index() 功能:识别某个特定的字符串是否包含在当前字符串中,并返回该特定字符串起始的位置索引值;如果未找到,则会引发异常。语法:通过调用对象的方法名.index(参数范围内的搜索起始索引值[, 参数范围内的搜索结束索引值])来实现功能
rfind的功能与find一致,并且其查找方向向右遵循以下语法:字符串序列.rfind(?串, 开始位置下标, 结束位置下标)
rindex() 功能:与index()功能相同,但查找的方向为右侧起始。语法:字符串序列.rindex(目标串, 起始位置下标, 结束位置下标)
count() 功能:统计某个特定字符序列在字符串中出现的频率 语法:字符串.count(?特定字符序列, 开始索引, 结束索引)
若省略开始和结束位置下标,表示在整个字符串序列中查找
修改(不能直接修改原字符串,需要赋值到变量)
方法 :
- replace 功能用于字符串替换操作 语法为字符串序列调用replace方法
- split 方法用于将字符串按指定分隔符分割 语法是字符串序列使用split方法
- join 方法可将多个字符或字符串合并形成新字符串 语法是多字符串序列调用join方法
- capitalize 方法仅将字符串的第一个字符转换为大写 语法为字符串序列直接调用capitalize方法
- title 方法可将每个单词的首字母转为大写 语法是字符串序列使用title方法
- lower 方法将所有字符转换为小写字母 语法为字符串序列调用lower方法
- upper 方法将所有字符转换为大写字母 语法是字符串序列使用upper方法
- lstrip 方法移除字符串左端的空白字符 语法为字符串序列直接调用lstrip方法
- rstrip 方法移除字符串右端的空白字符 语法是字符串序列使用rstrip方法
- strip 方法删除字符串两端的所有空白字符 语法为字符串序列直接调用strip方法
- ljust 方法通过填充指定字符(默认空格)使长度达到目标并左对齐 语法是多字符或串使用ljust方法
- rjust 方法通过填充指定字符(默认空格)使长度达到目标并右对齐 语法是多字符或串使用rjust方法
- center 方法通过填充指定字符(默认空格)使长度达到目标并居中显示 语法是多字符或串使用center方法
replace() 功能:替换 语法:字符串序列.replace(旧?串, 新?串, 替换次数)
split函数的功能:根据指定分隔符将字符串进行分割。定义:字符串序列.split(分隔符, 最大分割次数)
功能描述:join() 功能是将任意数量的字符或多个字符串合并为一个整体字符串;语法形式为:目标字符串.join(多个待连接的非空可迭代对象组成的列表)
make first character uppercase 功能:将字符串的第一个字符转换为大写字母,并使其余字符保持小写字母 语法:字符串序列使用make first character uppercase方法
title() 功能:将字符串每个单词?字?转换成?写 语法:字符串序列.title()
lower() 功能:将字符串中的?写全部转成?写 语法:字符串序列.lower()
upper() 功能:将字符串中的?写全部转成?写 语法:字符串序列.upper()
lstrip() 功能:删除字符串左侧空?字符 语法:字符串序列.lstrip()
rstrip() 功能:删除字符串右侧空?字符 语法:字符串序列.rstrip()
strip() 功能:删除字符串两侧空?字符 语法:字符串序列.strip()
ljust() 功能:实现将指定字符(默认为空格)填充至对应长度的新字符串,并使该新字符串左对齐;语法:字符串序列.ljust()
rjust()功能:通过指定字符(默认空格)填充达到对应长度的新字符串,并使字符串右对齐?语法:字符串序列.rjust()
中心化功能:通过将指定字符(默认为空格)填充至对应的宽度,并生成新的居中对齐的字符串;语法上使用字符串序列.center()方法。
判断
方法 :
以下是对输入文本的改写结果
startswith() 功能:用于判断一个字符串是否以指定的子串开头的行为。当满足条件时返回True;如果不满足条件则返回False。语法上表示为字符串序列(starts_with, starting_index, ending_index)的形式。
功能描述:该函数用于判断给定字符串是否以指定子串结尾,并根据判断结果返回布尔值True或False;语法规范如下:字符串序列.endsWith(str1, start1, end1)
isalpha() 功能:该函数用于判断输入的字符串是否仅包含一个字符,并且该字符属于字母集合;语法:通过调用字符串序列的属性.isalpha() 来实现功能
功能描述如下:当且仅当字符串仅包含数字时,则函数返回True;语法如下:字符串序列 . isdigit ()。
isalnum() 功能描述:该函数用于判断一个字符串是否仅包含字母或数字。若满足条件,则返回 True;否则返回 False。语法结构为:字符串序列.isalnum()
该方法用于检测字符串是否仅由空格或其他空白字符组成;若满足条件,则返回True;否则返回False。该方法的调用格式为字符串.isspace()
(5)列表
1、列表 :list,用来存储多个数据
2、创建列表 :[数据1,数据2,数据3,数据4…]
初始化一个空列表:[] 或 list()。
索引操作用于获取指定的元素或子集。
通过起始索引位置、终止索引位置和步长参数进行切分操作。
- 结束位置索引:当取值为-1时,默认取倒数最后一个元素
- 步长参数:即选取间隔,默认值设为1
- 步长参数支持正负整数值
- 步长参数可正可负
- 当步长参数设置为-1时,则表示从当前序列末尾开始向前遍历
- 最大允许的索引值设定为当前结束位置索引减一
- 步长参数:即选取间隔,默认值设为1
方法 :
- index() 的作用是获取指定元素的第一个出现位置,并会抛出异常错误提示当目标元素不存在时。
- count() 的作用是计算并返回给定范围内某个特定值出现的频率。
- 长度函数的作用是用来评估一个序列所包含元素的数量。
index() 功能:返回指定数据所在位置的索引值;若查询的数据不存在则会抛出异常;调用方法为列表序列.index(数据, 开始位置下标, 结束位置下标)
count() 功能:计算指定数据在当前列表中的出现频率 语法:列表序列中data属性的值
len() 功能:返回列表?度,即列表中数据的个数 语法:len(列表序列)
增加(直接在原列表?加指定数据,即修改原列表)
方法 :
- append() 的功能为:将数据添加到列表末尾;如果追加的数据是一个序列,则整个序列会被添加到列表中。其语法为:
列表序列.append(数据)。 - extend() 的功能为:将数据添加至列表末尾;如果追加的数据是一个序列,则此序列中的所有元素会被逐个添加到列表中。其语法为:
列表序列.extend(数据)。 - insert() 的功能为:在指定位置插入数据;其语法为:
列表序列.insert(位置下标, 数据)。
append() 功能模块:将数据添加至列表末尾。若要追加的数据为一个序列,则将整个序列添加至列表中。语法定义如下:
列表序列的append方法用于向其末尾添加数据。
extend() 功能:将数据附加至列表末尾;若追加的数据为一个序列,则该序列中的各项会被依次插入到列表中;语法:列表序列.extend(数据)
insert() 功能:在指定位置新增数据 语法:列表序列.insert(位置下标, 数据)
删除
方法 :
- del / del(*)**的功能:移除指定位置或满足特定条件的数据元素*** 语法:
del 列表序列/del(**列表序列[下标]**) - pop(*)的功能:默认删除最后一个元素,并返回该元素值*** 语法:
列表序列.pop(**下标**) - remove(*)的功能:移除符合条件的所有匹配项*** 语法:
列表序列.remove(**数据**) - clear(*)的功能:清空所有数据元素*** 语法:
列表序列.clear(**)**
del / del() 功能:用于删除列表中的元素或指定位置的数据 语法:通过del操作删除列表中的元素/使用索引指定位置进行数据去除
功能描述:移除指定索引位置的元素,默认情况下会删除最后一个元素,并返回被移除的元素值;语法为列表序列.pop(下标)
在Python中用于删除特定元素的方法是 remove() 功能:在某个列表中删除特定的数据项;语法为 列表序列.remove(数据)
clear() 功能:清空列表 语法:列表序列.clear()
修改
下标 :
列表序列[下标] = 新值方法 :
- reverse() 的 功能 是 进行 反转 ,其 语法 表达式为
列表序列.reverse()。- sort() 的 功能 是 对 列表 进行 排序 ,其 语法 表达式为
列表序列.sort(key=方法, reverse=布尔值)。
参数说明:key参数 表示 对 列表 内 每个 数据 应用 的 方法 (默认 不指定)reverse参数 控制 排序 方向 ,当 其 为 True 时 实现 降序 排列 (默认 是 升序)
- sort() 的 功能 是 对 列表 进行 排序 ,其 语法 表达式为
reverse() 功能:逆置 语法:列表序列.reverse()
sort() 功能在于排序 语法基于方法键入排序遵循布尔值规则 参数中 key指定对列表中每个元素施加的操作(默认无操作);reverse遵循布尔值指示 True表示降序排列 False表示升序排列(默认)
(6)元组
1、元组 :tuple,用来存储多个数据,但数据不能直接修改
假设存储的数据为可修改数据类型,则该数据结构(如列表)其成员元素是可以被更新的对象
2、创建元组 :(数据1,数据2,数据3,数据4…)
创建空元组:
()或tuple()
创建单个数据元组:(数据1,)
3、常用操作(查找)
下标 :
元组序列[下标]方法 :
- index() 功能:定位特定数据元素的位置信息;若元素存在则返回其索引值;否则触发异常错误 语法:
元组序列.index(目标元素)- count() 功能:统计指定元素在元组序列中的出现次数 语法:
元组序列.count(目标元素) - len() 功能:计算并返回元组中包含的元素总数 语法:
len(元组序列)
- count() 功能:统计指定元素在元组序列中的出现次数 语法:
index() 功能:用于获取特定的数据元素在序列中的位置信息的功能:当目标数据存在时会返回该元素在序列中的索引位置;如果未找到则抛出异常 语法:Python中用于获取元组中指定元素的索引位置的方法是index()函数
count() 功能:用于统计特定的数据项在当前元组中的出现频率 语法:通过调用元组序列的.count方法获取指定数据项的频率值
count() 功能:统计元组中数据的个数 语法:len(元组序列)
(7)字典
1、字典 :dict,字典??的数据以键值对(key:value)形式出现,但不?持下标
2、创建字典 :{key1:value1,key1:value2…}
创建空字典:
{}或dict()
修改/增加(直接在原字典?修改/增加数据,即修改原字典)
方法 :
- append() 的作用是:当字典中包含该键时会更新其值;否则会添加新的键值对。语法为:
字典[key] = 值
append() 操作:当字典包含该 key 时将对应 value 进行更新;若 key 不存在则新增键值对 语法定义为 字典[key] = value
方法 :
- del / del() 功能 :通过
del关键字移除一个或多个键值对自给定的字典对象 语法表达式 :del 字典Obj或del 字典Obj[key]- clear() 功能 :清除整个字典内容的全部键值对 语法表达式 :通过调用
.clear()方法来实现
- clear() 功能 :清除整个字典内容的全部键值对 语法表达式 :通过调用
del / del() 操作:用于从字典中移除键及其值 语法:通过 del 关键字来移除整个字典 / 或者仅删除特定键及其值
clear() 功能:清空字典 语法:字典.clear()
Index:dictionary[key value]表示从字典中查找某个键值对。如果当前对某个键进行查找操作且该键存在于字典中,则会返回与之匹配的值;否则不成功。
dict.get()的作用:当键不存在时,默认传入指定的第四个参数(默认值)。若未提供该参数则会返回 None;调用该方法可获取指定键对应的值。
语法:
dict.get(key, defaultValue)dict.keys()的作用:此方法用于获取一个字典的所有键;调用该方法可获取一个可迭代对象。
语法:
dict.keys()dict.values()的作用:此函数用于获取一个字典的所有值;通过调用该函数可以得到一个迭代器对象。
语法:
dict.values()dict.items()的作用:此函数用于获取一个字典中的所有键-值对;通过调用该函数可以得到一个迭代器对象。
语法:
dict.items()
get() 功能描述:当当前查找的key不存在时,默认返回指定的第二个参数;若未提供该参数,则返回 None
keys() 功能:返回字典中的所有key 语法:字典.keys()
values() 功能:返回字典中的所有value 语法:字典.values()
items() 功能:返回字典中的所有键值对 语法:字典.items()
(8)集合
1、集合 :set,可以去掉重复数据,但不?持下标
2、创建集合 :{数据1,数据2,数据3…}
创建空集合:
set()
增加
方法 :
- add方法实现了将数据加入集合的功能。
若追加的数据已存在于该集合中,则不会被添加。
语法:集合.add()- update方法用于将外部序列中的数据合并到本集合中。
该方法会逐项导入该外部序列的所有数据。
语法:集合.update(sequence)
- update方法用于将外部序列中的数据合并到本集合中。
**add() 功能:添加数据;若追加的数据已存在于当前集合中,则不会被添加?任何操作 语法:集合.add()
**update() 功能:追加序列数据,并将此序列的各项数据依次加入该集合 语法:集合.update()
方法 :
- remove() 功能:删除集合中指定的元素,并在该元素不存在时抛出异常;语法:
集合.remove(元素) - discard() 功能:移除集合中指定的元素而不抛出异常;语法:
集合.discard(元素) - pop() 功能:随机获取一个元素并将其从集合中移除(等价于调用 remove 方法),返回该被移除的值;语法:
集合.pop()
**remove() 功能:该方法的作用是删除集合中的指定元素。若指定的数据不存在则会抛出异常。其语法如下:集合中使用remove方法移除指定的数据。
discard() 作用:去除集合中的特定的数据元素,并且即使这些元素不存在也不会抛出异常 语法:集合.discard(data)
pop() 功能:随机删除集合中的某个数据,并返回这个数据 语法:集合.pop()
6. 转换数据常用方法
| 方法 | 说明 |
|---|---|
int(x [,base]) |
将x转换为?个整数 |
float(x) |
将x转换为?个浮点数 |
str(x) |
将对象 x 转换为字符串 |
list(s) |
将序列 s 转换为?个列表 |
tuple(s) |
将序列 s 转换为?个元组 |
set(s) |
将序列 s 转换为?个集合 |
complex(real [,imag]) |
创建?个复数,real为实部,imag为虚部 |
repr(x) |
将对象 x 转换为表达式字符串 |
eval(str) |
将str转换为str表达式原本的数据类型 |
chr(x) |
将?个整数转换为?个Unicode字符 |
ord(x) |
将?个字符转换为它的ASCII整数值 |
hex(x) |
将?个整数转换为?个?六进制字符串 |
oct(x) |
将?个整数转换为?个?进制字符串 |
bin(x) |
将?个整数转换为?个?进制字符 |
7. 数据容器的通用操作
1、运算符
| 运算符 | 描述 | ?持的容器类型 |
|---|---|---|
+ |
合并 | 字符串、列表、元组 |
* |
复制 | 字符串、列表、元组 |
in |
元素是否存在 | 字符串、列表、元组、字典 |
not in |
元素是否不存在 | 字符串、列表、元组、字典 |
2、常用方法
| 方法 | 描述 | 支持的容器类型 |
|---|---|---|
len() |
计算容器中元素个数 | 字符串、列表、元组、字典、集合 |
max() |
返回容器中元素最?值 | 字符串、列表、元组、字典、集合 |
min() |
返回容器中元素最?值 | 字符串、列表、元组、字典、集合 |
range(start,end,step) |
?成从start到end,步?为 step的数字列表,在for循环使?,做为数据对象的下标索引 | 字符串、列表、元组 |
enumerate(数据对象,start = ) |
将?个可遍历的数据对象组合为?个索引序列,同时列出数据和数据下标,start为索引起始值参数 | 字符串、列表、元组、字典、集合 |
3、推导式
列表:列表 = [xx for … in 数据序列]
# 举例:返回0-9的偶数列表
list1 = [i for i in range(10) if i % 2 == 0]
print(list1)
# [0,2,4,6,8]
java
# 举例:返回0-9的偶数列表
list1 = [i for i in range(10) if i % 2 == 0]
print(list1)
# [0,2,4,6,8]
java
字典:字典 = {xx1:xx2 for … in 数据序列}
# 举例:将两个列表内元素打包为字典
list1 = ['name', 'age']
list2 = ['Jack', 18]
dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1)
# {'name': Jack, 'age': 18}
java
# 举例:将两个列表内元素打包为字典
list1 = ['name', 'age']
list2 = ['Jack', 18]
dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1)
# {'name': Jack, 'age': 18}
java
集合:集合 = {xx for … in 数据序列}
# 举例:用集合形式打印列表内元素的2次方
list1 = [1, 1, 2]
set1 = {i ** 2 for i in list1}
print(set1 )
# {1,4}
java
# 举例:用集合形式打印列表内元素的2次方
list1 = [1, 1, 2]
set1 = {i ** 2 for i in list1}
print(set1 )
# {1,4}
java
8. 运算符
| 分类 | 运算符 |
|---|---|
| 算数运算符 | +、-、*、/、//、%、**、() |
| 赋值运算符 | = |
| 复合赋值运算符 | +=、-=、*=、/=、//=、%=、**= |
| ?较运算符 | =、!=、>、<、>=、<= |
| 逻辑运算符 | and、or、not |
1、算数运算符
| 运算符 | 描述 |
|---|---|
+ |
加 |
- |
减 |
* |
乘 |
/ |
除 |
// |
整除 |
% |
取余 |
** |
指数 |
() |
?括号 |
优先级 :
()?于**?于*///%?于+-
2、赋值运算符
| 运算符 | 描述 |
|---|---|
= |
赋值 |
3、复合赋值运算符
| 运算符 | 描述 |
|---|---|
+= |
加法赋值运算符 |
-= |
减法赋值运算符 |
*= |
乘法赋值运算符 |
/= |
除法赋值运算符 |
//= |
整除赋值运算符 |
%= |
取余赋值运算符 |
**= |
幂赋值运算符 |
优先级
- 在执行复合赋值运算符时,在先计算其右边部分。
- 接着进行其中涉及的数值计算部分。
- 最后完成变量赋值的过程。
先算复合赋值运算符右侧的表达式
再算复合赋值运算的算数运算
最后算赋值运算
4、?较运算符
返回 True 或 False
| 运算符 | 描述]= |
|---|---|
== |
等于 |
!= |
不等于 |
> |
大于 |
< |
小于 |
>= |
大于等于 |
<= |
小于等于 |
5、逻辑运算符
| 运算符 | 描述 |
|---|---|
and |
与 |
or |
或 |
not |
非 |
数字之间的逻辑运算
该θ运算符(AND运算)的特点在于:当输入中有θ(θ≥1)个输入值是零时(即至少一个输入值非零),其输出必然是零;如果所有输入均为零,则输出也为零。
OR运算的特点是:仅当所有输入均为零时其输出才会是零;一旦有任何一个输入非零,则输出即为此第一个非零数值.
and运算符,只要有?个值为0,则结果为0,否则结果为最后?个?0数字
or运算符,只有所有值为0结果才为0,否则结果为第?个?0数字
9. 输入输出
1、输?
语法:input(‘提示?字’)
input()将接收的所有数据视为字符串进行处理。
2、输出
语法:print(‘输出的字符串’)
语法:print(‘输出的字符串’)
转义字符
转义字符
\n:换?\t:制表符,?个tab键(4个空格)的距离- \n :换?
\t :制表符,?个tab键(4个空格)的距离
结束符
end="\n":默认结束符(默认换行),可修改- end=“\n” :默认结束符(默认换行),可修改
格式化输出
单一类型的.format()操作通常采用以下形式:通过调用函数或内置对象进行数据替换;多种类型的.format()方法允许同时替换多个字段或数据点;在Python 3.6及以上版本中,默认提供了f-string(format string literal)语法作为另一种高效的数据替换方式;单一类型.format()操作通常采用以下形式:通过指定占位符位置并替换相应的数据项实现功能
多个格式化输出:print(‘格式化符号1,格式化符号2’ % (表达式1, 表达式2))
Python3.6中新增的格式化?法:print(f’{表达式}')
常用格式符号
| 格式符号 | 转换 |
|---|---|
%s |
字符串 |
%d |
有符号的?进制整数 |
%f |
浮点数 |
%c |
字符 |
%u |
?符号?进制整数 |
%o |
?进制整数 |
%x |
?六进制整数(?写ox) |
%X |
?六进制整数(?写OX) |
%e |
科学计数法(?写e) |
%E |
科学计数法(?写E) |
%g |
%f和%e的简写 |
%G |
%f和%E的简写 |
- 该变量用于指示整数值的显示宽度为六位,并非零填充
- 此变量指定浮点数值的小数部分保留两位
%06d:表示输出的整数显示6位数,不?以0补全,超出当前位数则原样输出
%.2f:表示?数点后显示2位小数
10. 条件语句
if…
if 条件语句:
条件成?执?的代码
java
if 条件语句:
条件成?执?的代码
java
if…else…
if 条件语句:
条件成?执?的代码
else:
条件不成?执?的代码
java
if 条件语句:
条件成?执?的代码
else:
条件不成?执?的代码
java
多重判断
if 条件1:
条件1成?执?的代码
elif 条件2:
条件2成?执?的代码
else:
以上条件都不成?执?的代码
java
if 条件1:
条件1成?执?的代码
elif 条件2:
条件2成?执?的代码
else:
以上条件都不成?执?的代码
java
if嵌套
if 条件1:
条件1成?执?的代码
if 条件2:
条件2成?执?的代码
...
java
if 条件1:
条件1成?执?的代码
if 条件2:
条件2成?执?的代码
...
java
三?运算符:条件成?执?的表达式 if 条件 else 条件不成?执?的表达式
11. 循环语句
1、while 循环
while…
while 条件:
条件成?重复执?的代码
java
while 条件:
条件成?重复执?的代码
java
while…else…
while 条件:
条件成?重复执?的代码
else:
循环正常结束后执?的代码
java
while 条件:
条件成?重复执?的代码
else:
循环正常结束后执?的代码
java
2、for 循环
for…in…
for 临时变量 in 序列:
重复执?的代码
java
for 临时变量 in 序列:
重复执?的代码
java
for…in…else…
for 临时变量 in 序列:
重复执?的代码
else:
循环正常结束后执?的代码
java
for 临时变量 in 序列:
重复执?的代码
else:
循环正常结束后执?的代码
java
3、跳出循环
continue:跳出本次循环,继续执?下?次重复执?的代码
break:跳出整个循环,且不执?else里的代码
二、函数
1. 定义函数
函数的作?:封装代码,?效的代码复用
定义方法(函数必须先定义后使?)
def 函数名(参数):
# 也可以不带参数
代码
java
def 函数名(参数):
# 也可以不带参数
代码
java
2. 调用函数
调用方法:函数名(参数)
1、嵌套 :?个函数???调?了另外?个函数
# 举例:
def testB():
print('这?是testB函数执?的代码')
def testA():
print('---- testA start----')
testB()
print('---- testA end----')
testA()
# ---- testA start----
# 这?是testB函数执?的代码
# ---- testA end----
java

# 举例:
def testB():
print('这?是testB函数执?的代码')
def testA():
print('---- testA start----')
testB()
print('---- testA end----')
testA()
# ---- testA start----
# 这?是testB函数执?的代码
# ---- testA end----
java

2、递归 :函数内部??调???
# 举例:计算 1 + 2 + 3
def sum_numbers(num):
# 如果是1,则直接返回1
if num == 1:
return 1
# 如果不是1,则重复调用自己
return num + sum_numbers(num-1)
sum_result = sum_numbers(3)
print(sum_result)
# 6
java

# 举例:计算 1 + 2 + 3
def sum_numbers(num):
# 如果是1,则直接返回1
if num == 1:
return 1
# 如果不是1,则重复调用自己
return num + sum_numbers(num-1)
sum_result = sum_numbers(3)
print(sum_result)
# 6
java

3. 函数参数
作用:函数调?的时候可以传?真实数据,增?函数的使?的灵活性
形参:函数定义时的参数
实参:函数调?时的参数
1、位置参数
在函数被调用时,在遵循函数定义中各参数的位置后,并非必须一致地将形式参数与实际参数一一对应。
# 举例:
def user_info(name, age):
print(f'您的名字是{name}, 年龄是{age}')
user_info('Jack', 18)
# 您的名字是Jack, 年龄是18
java
# 举例:
def user_info(name, age):
print(f'您的名字是{name}, 年龄是{age}')
user_info('Jack', 18)
# 您的名字是Jack, 年龄是18
java
2、关键字参数
调?函数时,通过key=value形式加以指定,关键字参数之间不存在先后顺序
如果有位置参数,位置参数必须在关键字参数的前?
# 举例:
def user_info(name, age, gender):
print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
user_info('Jack', gender='男', age=18)
# 您的名字是Jack, 年龄是18, 性别是男
java
# 举例:
def user_info(name, age, gender):
print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
user_info('Jack', gender='男', age=18)
# 您的名字是Jack, 年龄是18, 性别是男
java
3、 默认参数
定义函数时,通过key=value形式为参数提供默认值
调?函数时,可以修改默认参数值
如果有位置参数,位置参数必须出现在默认参数前面
# 举例:
def user_info(name, age, gender='男'):
print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
user_info('Jack', 20)
# 您的名字是Jack, 年龄是20, 性别是男
user_info('Rose', 18, '?')
# 您的名字是Rose, 年龄是18, 性别是女
java
# 举例:
def user_info(name, age, gender='男'):
print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
user_info('Jack', 20)
# 您的名字是Jack, 年龄是20, 性别是男
user_info('Rose', 18, '?')
# 您的名字是Rose, 年龄是18, 性别是女
java
4、可变位置参数
收集所有位置参数,返回?个元组
# 举例:
def user_info(*args):
print(args)
user_info('Jack')
# ('Jack',)
user_info('Jack', 18)
# ('Jack', 18)
java
# 举例:
def user_info(*args):
print(args)
user_info('Jack')
# ('Jack',)
user_info('Jack', 18)
# ('Jack', 18)
java
5、可变关键字参数
收集所有关键字参数,返回?个字典
# 举例:
def user_info(**kwargs):
print(kwargs)
user_info(name='Jack', age=18, gender='男')
# {'name': 'Jack', 'age': 18, 'gender': '男'}
java
# 举例:
def user_info(**kwargs):
print(kwargs)
user_info(name='Jack', age=18, gender='男')
# {'name': 'Jack', 'age': 18, 'gender': '男'}
java
4. 函数返回值
1、返回值语法
返回单个数据:return 表达式
返回多个数据:
- 返回元组:
return 表达式1, 表达式2..或return (表达式1, 表达式2..) - 返回列表:
return [表达式1, 表达式2..] - 返回字典/集合:
return {表达式1, 表达式2..} - 返回元组:return 表达式1, 表达式2… 或 return (表达式1, 表达式2…)
返回列表:return [表达式1, 表达式2…]
返回字典/集合:return {表达式1, 表达式2…}
2、返回值拆包
列表/元组/集合拆包
# 举例:
def return_num():
return [100, 200]
# 也适用于以下表达式
# return 100,200
# return (100,200)
# return {100,200}
num1, num2 = return_num()
print(num1) # 100
print(num2) # 20
java

# 举例:
def return_num():
return [100, 200]
# 也适用于以下表达式
# return 100,200
# return (100,200)
# return {100,200}
num1, num2 = return_num()
print(num1) # 100
print(num2) # 20
java

字典拆包:取出来的是字典的key
# 举例:
dict1 = {'name': 'TOM', 'age': 18}
a, b = dict1
print(a) # name
print(b) # age
java
# 举例:
dict1 = {'name': 'TOM', 'age': 18}
a, b = dict1
print(a) # name
print(b) # age
java
交换变量值
- 方法一:借助第三变量存储数据
- 方法二:变量对调
# 举例:
a, b = 1, 2
a, b = b, a
print(a) # 2
print(b) # 1
python
方法一:借助第三变量存储数据
方法二:变量对调
# 举例:
a, b = 1, 2
a, b = b, a
print(a) # 2
print(b) # 1
java
# 举例:
a, b = 1, 2
a, b = b, a
print(a) # 2
print(b) # 1
java
5. 函数说明文档
定义文档语法
def 函数名(参数):
""" 说明?档的位置 """
代码
java
def 函数名(参数):
""" 说明?档的位置 """
代码
java
查看文档语法:help(函数名)
6. 变量作?域
全局变量:在函数体内、外都能?效的变量
局部变量:仅限于函数体内部起作用的变量(它们用于暂时存储数据,在函数完成操作后将被销毁)
在函数中修改全局变量:global关键字声明全局变量
# 举例:
a = 100
def test():
global a
a = 200
print(a)
test() # 200
java
# 举例:
a = 100
def test():
global a
a = 200
print(a)
test() # 200
java
7. 变量值的引用
通过引用机制实现为变量值传递的方式,在对变量进行修改操作时(即当其内存地址发生变化的情况发生时),我们可以将其划分为可变类型的和不可变类型的两种类型。
可变类型(内存地址不变):列表、字典、集合
不可变类型(内存地址有变化):整型、浮点型、字符串、元组
# 举例:1. 整型
a = 1
b = a
print(id(a)) # 140715006346912
print(id(b)) # 140715006346912
a = 2
print(id(a)) # 140715006346944,内存地址有变化
print(id(b)) # 140715006346912
java

# 举例:1. 整型
a = 1
b = a
print(id(a)) # 140715006346912
print(id(b)) # 140715006346912
a = 2
print(id(a)) # 140715006346944,内存地址有变化
print(id(b)) # 140715006346912
java

# 举例:2. 列表
aa = [10, 20]
bb = aa
print(id(aa)) # 2011069398720
print(id(bb)) # 2011069398720
aa.append(30)
print(id(aa)) # 2011069398720,内存地址不变
print(id(bb)) # 2011069398720
java
# 举例:2. 列表
aa = [10, 20]
bb = aa
print(id(aa)) # 2011069398720
print(id(bb)) # 2011069398720
aa.append(30)
print(id(aa)) # 2011069398720,内存地址不变
print(id(bb)) # 2011069398720
java
使用id()函数可以识别两个变量是否为同一值的引用,并且id值代表变量在内存中的地址
8. lambda表达式
1、适用场景 :函数有?个返回值,且只有?句代码
2、语法 :lambda 参数列表:表达式
- lambda表达式能够接受任意数量的参数。
- 直接打印该lambda表达式。
- 输出的结果是该lambda所占用内存地址。
- lambda表达式能够接受任意数量的参数。
- 但只能返回指定数量的值。
- 直接打印该lambda表达式。
直接打印lambda表达式,输出的是此lambda的内存地址
3、lambda的参数形式
?参数:lambda: 表达式
位置/关键字参数:lambda 参数:表达式
默认参数:lambda key=value:表达式
*可变位置参数:lambda args:表达式
**可变关键词参数:lambda kwargs:表达式
# 举例:使列表数据按字典key的值排序
students = [
{'name': 'TOM', 'age': 20},
{'name': 'ROSE', 'age': 19},
{'name': 'Jack', 'age': 22}
]
# 按name值升序排列
students.sort(key=lambda x: x['name'], reverse=False)
print(students)
# [{'name': 'Jack', 'age': 22}, {'name': 'ROSE', 'age': 19}, {'name': 'TOM', 'age': 20}]
java

# 举例:使列表数据按字典key的值排序
students = [
{'name': 'TOM', 'age': 20},
{'name': 'ROSE', 'age': 19},
{'name': 'Jack', 'age': 22}
]
# 按name值升序排列
students.sort(key=lambda x: x['name'], reverse=False)
print(students)
# [{'name': 'Jack', 'age': 22}, {'name': 'ROSE', 'age': 19}, {'name': 'TOM', 'age': 20}]
java

9. 高阶函数
1、高阶函数作? :把函数作为参数传?,化简代码
# 举例:任意两个数字,按照指定函数处理后再进?求和计算
def sum_num(a, b, f):
return f(a) + f(b)
result = sum_num(-1, 2, abs)
print(result) # 3
java
# 举例:任意两个数字,按照指定函数处理后再进?求和计算
def sum_num(a, b, f):
return f(a) + f(b)
result = sum_num(-1, 2, abs)
print(result) # 3
java
2、内置?阶函数
map()
语法:map(func, lst)。该函数将传递给参数func的函数作用于序列lst中的每个元素,并将其结果组合成一个新的迭代器返回。
# 举例:将列表内元素依次乘以2次方
list1 = [1, 2, 3, 4, 5]
def func(x):
return x *
result = map(func, list1)
print(result) # <map object at 0x000001D43D121C70>
print(list(result)) # [1, 4, 9, 16, 25]
java
# 举例:将列表内元素依次乘以2次方
list1 = [1, 2, 3, 4, 5]
def func(x):
return x *
result = map(func, list1)
print(result) # <map object at 0x000001D43D121C70>
print(list(result)) # [1, 4, 9, 16, 25]
java
filter()
语法:filter(func, lst) 用于筛选出满足条件的元素,并返回相应的 filter 对象数量
# 举例:去掉列表中的奇数
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def func(x):
return x % 2 == 0
result = filter(func, list1)
print(result) # <filter object at 0x000001D43D121AC0>
print(list(result)) # [2, 4, 6, 8, 10]
java
# 举例:去掉列表中的奇数
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def func(x):
return x % 2 == 0
result = filter(func, list1)
print(result) # <filter object at 0x000001D43D121AC0>
print(list(result)) # [2, 4, 6, 8, 10]
java
reduce()
语法规则:在Python中使用reduce(func, lst)的形式,在JavaScript中则是调用foldl(func, lst)或foldr(func, lst)。该函数会将每次计算所得的结果传递给下一个元素进行处理,并且函数必须接受两个参数。
# 举例:计算列表中各个数字的累加和
import functools
list1 = [1, 2, 3, 4, 5]
def func(a, b):
return a + b
result = functools.reduce(func, list1)
print(result) # 15
java
# 举例:计算列表中各个数字的累加和
import functools
list1 = [1, 2, 3, 4, 5]
def func(a, b):
return a + b
result = functools.reduce(func, list1)
print(result) # 15
java
