基础函数
|
显示
|
print()
|
print
(
"hello word"
)
|
|
输入
|
input()
|
a =
input
(
"
输入需要输入的数值
"
)
|
|
返回字符长度（数字类型无法返回）
|
len()
|
a =
len
(
'adsfew'
)
|
|
最大的成员（中文符号>字母>数字>英文符号）
| max() |
b =
max
(
1
,
2
,
3
,
4
,
5
)
|
|
最小的成员
|
min()
|
b =
min
(
1
,
2
,
3
,
4
,
5
)
|
|
返回数据类型
|
type()
|
print
(
type
(b))
|
|
定义字符串：
|
str()
|
b =
str
(
'123456'
)
|
常见
数据类型
|
数据类型
|
整形： int
|
浮点： float
|
|
字符串类型
|
用''或" "包裹的所有数据都是字符串
|
字符串的累加：字符串的拼接，用“+”这个符号
|
|
布尔类型
|
True/False
|
布尔类型是一种判断事情正确与错误的类型
|
|
空类型
|
None
|
空类型就是没有任何类型的类型，比如None代表空。
|
四大主流数据类型
|
列表list[]
| 列表就是队列，它是各种数据类型的集合，也是一种数据结构，列表是一种有序，且内容可以重复的集合类型。 |
|
元组tuple（）
|
元祖比列表占用资源更小,列表是可变的，元祖是
不可变的,元祖一旦创建就
不可修改了,元组相比列表更
节省内存。
|
|
字典dict（：）
|
字典是由多个键（key）及其对应的值（value）所组成的一种数据类型字典中每个key一定是唯一的key支持字符串，数字和元组类型，但
不支持列表。value支持所有python类型可以根据字典的key获取字典的value。字典是
无序的
|
|
集合set{}
|
集合是一个
无序的不重复序列，常用来对两个列表进行交、并、差的处理性集合与列表一样，支持所有数据类型
|
对象
|
什么是对象？
|
python中一切都是对象，每个对象都有格子的属性与方法，对象里的特点就是它的属性，它的功能就是它的方法。
|
字符串
|
字符串首字母大写
|
capitalize（）
|
用法：
newstring = string.capitalize()
参数：括弧内什么都不用填写
|
|
字符串全体大写
|
upper()
|
big_str = string.upper()
括弧内什么都不用填
|
|
字符串全体小写
|
casefold()与lower()
|
newstr = string.casefold() newstr = string.lower()
|
|
字母大小写转换
|
swapcase（）
|
newstr=string.swapcase()
括弧内什么都不用写
|
|
为字符串定义长度，缺少的部分用0填补
|
zfill（）
|
newstr = string.zfill(width)
参数：
width
：新字符串希望的宽度
|
|
返回当前字符串中某个成员（元素）的个数
|
count（）
|
inttype = string.count(item)
参数：
item
：查询个数的元素。
|
|
判断字符串开始位是否是某位成员
|
startswith(item, start, end)
|
string.startswith(item) item
：你想查询匹配的元素，返回一个布尔值
|
|
endswith判断字符串结尾是否是某成员
|
str.endswith(item, start, end)
|
string.endswith
（
item
）
item:
你想查询匹配的元素，返回一个布尔值
|
|
查询元素
|
find（item）
|
string.find(item)
返回一个整形
(
字符串里是从左向右，以
0开始
)
|
|
index(item）
|
string.index(item) item:
你想查询的元素，返回一个整形或者报错。
| |
|
将去掉 字符串左右两边的指定元素，默认是空格
|
strip(item)
|
newstr = string.strip(item)
参数：括弧里需要传一个你想去掉的元素，
可不填写。
|
|
将字符串中的old替换成new，并能指定替换的数量。
|
replace(old,new,max)
|
用法：
newstr = string.replace(old,new,max)
参数：
old:
被替换的元素，
new:
替代
old
的新元素，
max:
可选，代表替换几个，默认全部替换全部匹配
的
old
元素。
多组替换
newstr = string.replace(old,new).replace(old,new)
|
|
返回bool类型的函数
| ||
|
判断字符串是否是一个由空格组成的字符串
|
isspace()
|
用法：
booltype = string.isspace()
无参数可传，返回一个布尔类型。
|
|
判断字符串是否是一个标题类型
|
istitle()
|
用法
:booltype = string.istitle()
无参数可传，返回一个布尔类型。
|
|
判断字符串中的字母是否都是大写。islower判断字符串中的字母是否都是小写。
|
isupper()和islower()
|
booltype = string.isupper()
无参数可传，返回一个布尔类型。
booltype = string,islower()
无参数可传，返回一个布尔类型。
|
|
容器对象 拆分并以指定的字符将列表内的元素(element)连接起来，返回
字符串
|
join（）
|
a = ['no', 'pain', 'no', 'gain'] '_'.join(a)
变 ：
no_pain_no_gain
|
|
以指定的字符将字符串分割为单个元素(字符类型)并加入list中，返回一个List
|
split（）
|
a = 'no_pian_no_gain a.split('_')
变
['no', 'pian', 'no', 'gain']
|
字符串的编码格式
|
什么是编码格式？
|
有一定规则的规则。使用了这种规则，我们就能知道传输的信息是什么意思。
|
|
gbk
|
编码中文编码格式
|
|
ascii
|
编码英文编码格式
|
|
utf-8
|
一种国际通用的编码格式
|
字符串的格式化
|
什么是格式化
|
一个固定的字符串中有部分元素是根据变量的值而改变的字符串。
|
|
为什么使用格式化及场景
|
对于重复性很多的信息，通过格式化的形式，可以减少代码的书写量。
|
|
字符串格式化使用操作符%来实现
|
‘my name is %s,my age is %s’%('dewei',33)
|
|
字符串格式化函数format
|
string.format 函数用来格式化字符串。使用fromat的字符串主体使用｛｝大括号来替代格式符。string.format(data,data,data...)
|
|
python3.6加入新的格式化方案f-strings
|
定义一个变量，字符串前加f符号，需要格式化的位置使用｛变量名｝
|
|
f 表达式----可以解析任意的数据类型
|
name = '键盘'
age = 18
a = f"姓名：{name} 年龄：{age}"
print(a)
print(f"姓名：{name} 年龄：{age}")
|
字符串的格式化符号
|
%s
|
格式化字符串，通用类型
|
|
%d
|
格式化整形
|
|
%f
|
格式化浮点型
|
|
%U
|
格式化无符号整形（正整型）
|
|
%C
|
格式化字符
|
在大括号中%用：来代替
|
%o
|
格式化无符号八进制数
|
|
%x
|
格式化无符号16进制数
|
|
%e
|
科学计数格式化浮点数
|
转义字符
|
什么是转义字符
|
字符串要转成其他含义的功能，所以我们叫他转义字符
|
|
\n
|
换行，一般用于末尾，strip对其也有效
|
|
\t
|
横向制表符（可以认为是一个间隔符）
|
|
\v
|
纵向制表符（会有一个男性符号）
|
|
\a
|
响铃
|
|
\b
|
退格符，将光标前移，覆盖（删除前一个）
|
|
\r
|
回车
|
|
\f
|
翻页（几乎用不到，会出现一个女性符号）
|
|
\'
|
转义字符串中的单引号
|
|
\\''
|
转义字符串中的双引号
|
|
\\
|
转义斜杠
|
|
在python中字符串前加r来将当前字符串的转义字符无效化
|
列表[]与元组（）
|
将一个元素添加到当前列表中
|
append()
|
list.append(new_item)
参数：
new_item
添加进列表的新元素.
被添加的元素只会被添加到末尾，append函数是在原有列表的基础上添加，不需要额外添加新的变量。
|
|
将一个元素添加到当前列表的指定位置中
|
insert(index,new_item)
|
list.insert(index
，
new_item)
参数：
index:
新的元素放在哪个位置。
new_item:
添加的新元素
.
如果位置不存在，则将新元素添加到列表结尾。
|
| 返回当前列表中某个元素的个数 |
count(item)
|
inttype= list.count(item)
参数
item
：你想查询个数的元素
|
|
删除列表中的某个函数
|
remove与del
|
list.remove(item)
元素有多个只会删第一个，没有则报错
|
|
对当前列表顺序进行反转
|
reverse（）
|
drinks.reverse() drinks
：要反转的列表
|
|
按一定规律进行排序
|
sort(cmp=None,key=None,reverse=False)
|
ist.sort(cmp=None,key=None,reverse=False) cmp
可选参数，制定排序方案的函数，
key
参数比较，
reverse
排序规则
|
|
删除列表中所有元素
|
list.clear()
|
list.clear()
该函数无参数，无返回值
|
|
将当前的列表复制一份相同的列表，新列表与旧列表内容相同，但内存空间不同。
|
copy（）
|
list.copy()
该函数无参数，返回一个一模一样的列表
.
|
|
将其他列表或元祖中的元素倒入到当前列表中
|
extend
|
list.extend(iterable)
参数：
iterable
代表列表或元组，该函数无返回值
.
|
字典[ key：value]
|
添加新的字典，如新的字典中有和元字典相同的key,则该key的value会被新字典的value覆盖
|
update
|
dic.update(new_dict)
该函数无返回值
|
|
获取某个key的value，如key不存在于字典中，将会添加key并将value设为默认值
|
setdefault
|
dict.setdefault(keyvalue)
参数：
key
需要获取的
key
。
value
如果
key
不存在，对应这个
key
存入字典的默认值。
|
|
可以获取当前字典中所有的键（key）
|
keys
|
dict.keys()
无需传参，返回一个
key
集合的伪列表
|
|
获取当前字典中所有键值对中的值（value）
|
valuse
|
dict.values()
无需传参，返回一个
value
集合的伪列表
|
|
获取当前字典中指定key的value
|
get
|
dict.get(key,default=None)
参数：
key
需要获取
value
的
key
，
default
：
key
不存在则返回此默认值，默认是
None
，
|
|
字典+中括号内传key，不进行赋值操作即为获取
|
[]
|
name= my_dict['name'] 返回name对应value
|
|
清空当前的字典 中所有的数据
|
clear()
|
dict.clear()
无参数 ，无返回值
|
|
删除字典中指定的key，并将其结果返回，如果key不存在则报错
|
pop
|
dict.pop(key) key
希望被删掉的键 返回这个
key
对应的值（
value
）
|
|
删除
|
del
|
del my_dict['name']
删除字典中这个
key
及对应
value
|
|
copy将当前的字典复制一个新字典（内存地址不同）
|
copy
|
dict.copy()
该函数无参数，会返回一个一模一样的内存地址不同的字典
|
|
删除当前字典里末尾一组键值对并将其返回,如果字典为空直接报错
|
popitem
|
dict.popitem()
无需传参
|
集合
|
增
|
set.add(item)
|
set.add(item)
没有参数返回值
|
|
删
|
set.remove()
|
set.remove(item) item:
当前集合中的一个元素 返回值：无返回值，直接作用于原集合
|
|
改
|
update(iterable)
|
set.update(iterable) iterable:
集合，列表元组字符串 返回值：无返回值，直接作用于原集合
|
|
差集
|
difference（）
|
da_set.difference(b_set)
参数
b_set
当前集合需要对比的集合
|
|
并集
|
union(b,c)
|
a.union(b,c)
括号中可以有多个
set
，以此返回
a
与
b
、
c
的并集
|
|
判断集合中是否包含相同元素
|
isdisjoint（）
|
a_set.isdisjoint(b_set)
：判断两个集合是否具有相同的元素。没有则返回
True
，有则返回
False
。只能一次传入一个
b_set
参数。
|
不同数据类型间的转换
|
原始类型
|
目标类型
|
函数
|
举例
|
|
整型
|
字符串
| str | new_str=str(123456) |
|
浮点型
|
字符串
| str |
new_str= str(3.14)
|
|
字符串
|
整型
| int |
new_int =int('12')
|
|
字符串
|
浮点型
| float | new_float=float('1.2') |
|
字符串
|
列表
| split |
string.split(sep=None,maxsplit=-1) 参数：sep切割的规则符号,不填写，默认空格，如字符串无空格不分割生产列表 maxsplit:根据切割符号切割的次数，默认-1无限制
|
|
列表
|
字符串
| join |
'sep'.jion(iterable) 参数：sep:生成字符串用来分割列表每个元素的符号。 iterable 非数字类型的列表或元组或集合
|
|
集合、字符串、列表
|
列表
|
sorted(iterable)
| |
|
字符串
| b'ytes |
encode
|
string.encode(encoding='utf-8',errors='strict')参数：encoding:转换成的编码格式，如ascii,gbk,默认 utf-8. errors:出错时的处理方法，默认strict
|
|
b'ytes
|
字符串
|
decode
|
bytes.decode(encoding='utf-8',errors='strict')参数：encoding:转换成的编码格式，如ascii,gbk.默认utf-8. errors: 出错时的处理方法，默认strict,直接抛错误，也可以选择ignore忽略错误。 返回值：返回一个字符串类型
|
列表、集合、元祖之间的转换
|
原始类型
|
目标类型
|
函数
|
举例
|
|
列表
|
集合
| set |
new_set = set([1,2,3,4,5])
|
|
列表
|
元组
| tuple |
new_tuple = tuple([1,2,3,4,5])
|
|
元组
|
集合
| set |
new_set =set((1,2,3,4,5))
|
|
元组
|
列表
| list |
new_list=list((1,2,3,4,5))
|
|
集合
|
列表
| list |
new_list=list({1,2,3,4,5})
|
|
集合
|
元组
| tuple |
new_tuple = tuple({1,2,3,4,5,})
|
流程控制
|
if bool_result:
do
else:
|
参数：bool_result：判断结果的真假，布尔类型
do 如果bool_result为True时执行任意python代码，
返回值 if属于关键字，没有返回值.else就是对于if提不满足条件时候执行的另一个代码块的入口
|
循环
|
for item in iterable：
print（item）
|
|
参数：for 循环语法块，iterable 可循环的数据类型。 item iterble中的每一个元素 返回值：for循环是语句，没有返回值，但在特定情况下有返回值
|
|
python的内置函数range
|
|
for item in range(start,stop,step=1): print(item)参数： start:开始的数字，类似索引的左边 stop ：结束的数字，类似索引的右边 step: 跳步，类似索引中的第三个参数
|
|
continue与break
|
|
遇到Continue时，跳出本次循环，执行循环体的下次循环；遇到break则结束整个循环
|
|
列表推导式
|
|
print([x ** 2 for x in range(20) if x % 2 == 0]) 列表推导式又名列表解析式，是一种快速创建列表的简洁语法
|
while循环
|
以一定条件为基础的循环，条件满足则无限循环，条件不满足退出循环。
|
while循环
|
while bool_result do
参数：bool_result: 布尔类型，此处与if语法完全一致。 do:while循环体的代码块 # 需要缩进 返回值： while循环是语句，没有返回值.
|
|
永动机
|
while True
|
一直执行
|
函数
|
函数
| |||
|
内置函数
|
print();
id
int
str
max
min
range
| ||
|
自定义函数
|
通过关键字def创建
| ||
|
定义函数
|
def name(args...):
todo something...
返回值
|
只有函数才有返回值，但不是必须的
todo something...代码块
| |
|
函数的结果返回-
|
return
|
将函数结果返回的关键字，return只能在函数体内使用。
| |
|
示范
|
特征
|
定义
| |
|
必传参数
| |||
|
函数中定义的参数没有默认值，在调用函数时如果不传入则报错
|
def add(a,b)
调用时如果add()则报错。
add(1,2)则正确调用
|
在定义含函数的时候，参数后边没有等号与默认值。
|
在定义函数的时候，没有默认值且必须在函数执行的时候传递进去的参数，且顺序与参数顺序相同，就是必传参数。
|
|
默认参数
| |||
|
在定义函数的时候，定义的参数含有默认值，通过赋值语句给他是一个默认的值
|
def add(a,b=1):
return a+b
赋值等号-默认值
|
如果默认参数在调用函数的时候给予了新的值，函数将优先使用后传入的值进行工作。
| |
|
不确定参数-可变参数
|
def add(*args,**kwargs):
add(1,2,3, name='dawei',age=33)
1,2,3 对应*args
name='dawei',age=33 对应**kwargs
|
*args代表：将无参数的值合并成元组
**kwargs代表将有参数与默认值的赋值语句合并成字典。
| |
|
例1
|
def add(*args, **kwargs):
print(args, type(args))
print(kwargs, type(kwargs))
add(1,2,3,name='daw')
输出：
(1, 2, 3) <class 'tuple'>
{'name': 'daw'} <class 'dict'>
|
**kwargs为字典储存
*args为元组储存
| |
|
例2
|
def test_args_super(*args,**kwargs):
print(args, type(args))
print(kwargs, type(kwargs))
a = ('python', 'django')
b = {'name': 'dewei'}
test_args_super(a,b)
输出
(('python', 'django'), {'name': 'dewei'}) <class 'tuple'>
{} <class 'dict'>
|
**kwargs为字典储存
*args为元组储存一个*将无参数名的值包含起来封装成元组。
将
test_args_super(*a
,
**b)
即可正常传入对应的值
| |
|
参数规则
|
def add(a,b=1,*args,**kwargs)
参数的定义从左到右依次是 必传参数，默认参数，可变元组参数？，可变字典参数
|
函数的参数类型定义
| 例子 |
def add(a:int,b:int=3):
print(a+b)
add(1,2)
add('hello','xiao')
|
|
特性
|
1.传参不按默认值来时，以传参为准
2.不按默认类型来时，以传参为准
|
全局变量
|
全局变量
|
全局变量可以在函数内被读取使用，但无法修改
|
name = 'dewei' #在python脚本最上层代码块的变量，全局变量可以在函数内被读取使用
def test():
print(name)
|
|
局部变量
|
在函数体内定义得变量，在函数外使用会报错
|
def test():
name = 'dewei' #在函数体内定义得变量
print(name)
test()
|
|
global
|
将全局变量在函数体内进行修改
|
name = 'dewei' #定义一个全局变量
def test():
global name #global+全局变量名 函数体内给全局变量重新赋值
name = '小木'
print(name)
# 工作中，不建议使用global对全局变量进行修改
test()
|
递归函数
|
递归函数
| 一个函数不停的将自己反复执行 |
def test(a):
print(a)
return test(a)
test(1)
|
匿名函数Iambda
|
Iambda
|
定义一个轻量化的函数，即用即删除，适合完成一项功能，但是此功能只在此一处使用。
|
# 无参数
f = lambda: 'strvalue'
# 可以理解成lambda函数后面放参数，冒号后面放函数
print(f())
# 有参数
z = lambda x, y: x*y
# 注意顺序，必传参数在前面，默认参数在后面
print(z(3, 4))
|
避坑指南-
函数定义de与使用常见问题
1、函数名和系统函数重名
|
def len(x):
res = 1
for i in x:
res *= i
return res
list_1 = [1, 2, 3]
print(len(list_1))
|
运行结果
|
6
|
列表list_1的长度是3，而程序结果输出6，并没有正确的输出列表的长度。
说明：len()函数是Python内置函数，可以用于计算列表长度，程序中定义了len()函数，与内置函数重名，对列表list_1应用len()函数，调用的是自定义函数，没有实现列表长度的计算。
2、默认参数
|
def demo(x=10, y):
sum = x + y
return sum
result =demo(1,5)
print(result)
|
运行结果
|
SyntaxError: non-default argument follows default argument
|
说明：带有默认值的参数必须在参数列表末尾，应修改为def demo(y,x=10)
3、返回值
|
def demo(x,y):
sum = x + y
print(sum)
result = demo(1,5)
print(result)
|
运行结果
|
6
None
|
说明： demo()函数没有return语句，函数默认返回值None,即result为None，因此执行print(result)输出None.
4.多个返回值
|
def demo(x,y):
z1 = x + y
z2 = x - y
z3 = x * y
z4 = x / y
return z1, z2, z3, z4
result = demo(20,5)
print(result)
print(result[0])
print(result[1])
print(result[2])
print(result[3])
|
运行结果
|
(25, 15, 100, 4.0)
25
15
100
4.0
|
说明：函数可以返回多个值，以元组的形式返回。
函数默认参数为list的注意事项
定义demo（）函数，两个参数，默认参数值为空列表，代码如下：
|
def demo(x, list_1=[]):
for i in range(x):
list_1.append(i * i)
print(list_1)
# 连续2次调用demo()函数
demo(3)
demo(4)
|
运行结果
|
[0, 1, 4]
[0, 1, 4, 0, 1, 4, 9]
|
调用demo[4],预期结果应该是[0,1,4,9],而实际结果是[0,1,4,0,1,4,9]。
为什么呢？
当定义demo()函数时，会保存函数中默认参数list_1的值，也就是空列表[]；
在调用函数时如果传递了列表，使用传递的列表；如果没有传递列表，则使用函数定义时保存的默认参数list_1。
详解如下：
1、执行demo(3)，没有传递默认参数list_1,对函数定义时list_1进行元素添加操作，此时list_1的值是[0,1,4];
2、执行demo(4),也没有传递默认参数list_1，操作的仍然是函数定义时的list_1，将demo(4)得到的新元素0，1，4，9，继续添加
到列表list_1中，此时list_1的值是[0,1,4,0,1,4,9].
对程序进行如下改变，在demo()函数中打印list_1对应的内存地址，第二次调用时为默认参数传递一个值。
|
def demo(x,list_1=[]):
print("list_1",id(list_1))
for i in range(x):
list_1.append(i*i)
print(list_1)
demo(3)
demo(4,[])
demo(4)
|
运行结果如下
|
list_1 1493838654848
[0, 1, 4]
list_1 1493838655168
[0, 1, 4, 9]
list_1 1493838654848
[0, 1, 4, 0, 1, 4, 9]
|
从运行结果可以看出，执行demo(3)与执行demo(4)打印的list_1内存地址相同，而执行demo(4,[])打印的list_1内存地址不一样。
说明：调用函数时传递了列表,函数体中使用传递的列表；没有传递，使用函数定义时的列表，所以会产生以上结果。
对demo()函数进行如下修改，每次调用时先将默认的list清空，然后再进行元素添加操作，也可以实现预期效果。
|
def demo(x, list_1=[]):
list_1 = [] #将list_1置位空列表
for i in range(x):
list_1.append(i *i)
print(list_1)
demo(3)
demo(4)
|
运行结果
|
[0, 1, 4]
[0, 1, 4, 9]
|
扫一扫
522
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
