python基础练习

一级标题(CTRL+1)

二级标题(CTRL+2)

···以此类推

插入代码块 鼠标右击 CTRL+/ 转换为原码

System.out.println("唐友吃不着鸡");

图片

```shell

```

• 路径种类:

• 网络上图片的实际网址

• 本地中的绝对路径

• 本地中的相对路径

• Python、pycharm安装

• Python的三种运行方式

  终端、脚本、IDE
  

注释

#这是单行注释

"""
这是多行注释1
"""

'''
这是多行注释2
'''

print()输出

print("hello")
print('hello')
print("""
	hello
	""")
print('''
	hello
	''')

print(help(print))
#查看打印的类型

input 函数

a = input("请输入信息>>>")
print(a)
print(type(a))

• input()函数中可以给提示信息，但本身不会传递给相关变量，只有输入的值才会传递。

• input()函数的返回值为字符串类型，可以用type()函数测试

数据:

• 文本
• 图形
• 音频
• 视频
• 网页数据
• 等等

不同的数据，我们需要定义不同的数据类型。

python的常见数据类型:

• 数字(number){

  1. 数字提供了标量存储和直接访问
  2. 是不可更改的数据类型(指变更数字会生成新的对象)

  }

  • 整型(int){

    ​ Python有几种整数类型，布尔类型是只有两个值的整型，常规整型是绝大多数

    ​ Python2区分整型和长整形，Python3不区分

    }

  • 长整型(long)

  • 浮点型(float){又分为双精度浮点型和十进制浮点型

    ​ 十进制浮点型:

    ​ python3中说浮点型

    主要知道科学计算法

    print(2.3124E4)
    print(4000e-3)
    """
    23124.0
    4.0
    大小写e都可以，代表
    """
    

    }

  • 复数(complex){

    x ** 2 = -1 x的平方等于-1 任何一个实数的平方都是一个非负数。

    但是现在一个数的平方我们要让他得到一个负数，怎么办?

    所以，18世纪的数学家们定义了虚数(i,j, 虚数基本单位，i ** 2 = -1 , j * *2 = -1)

    属性:

    ​ num.real 该复数的实部

    ​ num.imag 该复数的虚部

    ​ num.conjugate 返回该复数的共

    ​ }

• 字符串(String)

• 布尔型(Bool){True/False(1,0)}

• 列表(list)

• 元组(tuple)

• 集合(set)

• 字典(dict)

变量

• 概念:
  • 程序可操作的存储区名称
  • 程序运行存储区中能改变的数据
  • 每个变量都有特定的类型
• 作用:将数据存储到内存；
• 变量的定义

变量名 = 初始值(初始值的实际类型决定变量的数据类型)

• 变量的命名
  • 必须由字母、数字、下划线组成；
  • 不能以数字开头(但是由于Python中单下划线("_")和双下划线("__")名称的变量有特殊用途，因此不推荐自定义单下划线和双下划线开头的变量
  • 不能是Python中的关键字

变量命名尽可能见名知意:

大驼峰、小驼峰

首先，看一下关键字:

import keyword
print(keyword.kwlist)

'''
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
'''

• 变量类型查看

type(变量名)

• 变量内存地址

id(变量名)

dir():对应之前所有变量
dir(a): 参数里所有的变量和属性

举例

a = 1
print(a,type(a),id(a))
b = "Hunan"
print(b,type(b),id(b))
a = 1
print(a)
del a
print(a)

ApplePrice/Apple_Price

• 变量的调用

a = 1
b = 6
c = a + b
print(c)

调用变量的时候，变量实现必须与定义，否则报错

常量

常量即不变的量，比如，π 3.1415926,或者程序运行过程中不可以更改的量。

一般常量的定义全部都用大写

π = 3.14

# 交换变量
x = 2
y = 3
x,y = y,x
print(x,y)

# 同时赋值
a = b = c = 3
print(a,b,c)
# a,b,c= 3  #报错
a,b,c= 1,2,3  #同步赋值,---对应
print(a,b,c)
b = 1,2  #返回一个元组
print(b)

运算符	描述	实例
+	加 : 两个对象相加	a + b
-	减 :得到负数或是一个数减去另一个数	a - b
*	乘 : 两个数相乘或是返回一个被重复若干次的字符串	a * b
/	除 : x 除以 y	b / a
%	取模 : 返回除法的余数	b % a
**	幂 : 返回x的y次幂	a**b
//	取整除 : 向下取接近除数的整数	a//b

a = 27
b = 4
print(a/b)
print(a//b)
print(a%b)
"""
6.75
6
3
"""

Python的比较运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 True。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。	(a < b) 返回 True。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 True。

Python赋值运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	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

python中没有++，–这种写法

Python位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

运算符	描述
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。
^	按位异或运算符：当两对应的二进位相异时，结果为1
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1
<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。
>>	右移动运算符：把">>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数

关于取反：

下表中变量 a 为31，b为 15二进制格式如下:

a = 31
b = 15
print(bin(a))
print(bin(a<<2))
print(bin(b))
print(bin(b>>2))
print(a&b)
print(a|b)
print(a^b)
print(~b)

"""
0b11111
0b1111100
0b1111
0b11
15
31
16
-16
"""

Python逻辑运算符

Python语言支持逻辑运算符，

运算符	逻辑表达式	描述
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。
or	x or y	布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

同样仍以变量 a 为 31，b 为 15为例：

a = 31
b = 15
print(a<3 and b>12)
print(a<30 or b>12)
print(not a)

"""
False
True
False
"""

1. 在没有()的情况下not优先级高于 and，and优先级高于or，即优先级关系为()>not>and>or,同一优先级从左往右计算

判断逻辑语句的正与负:

3>4 or 4<3 and 1==1 #
1 < 2 and 3 < 4 or 1>2 #
2 > 1 and 3 < 4 or 4 > 5 and 2 < 1 #
1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8 #
1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 > 8 #
1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6 #
not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6#
"""
False
True
True
False
True
False
False
"""

and(逻辑与)	0	1
0	0	0
1	0	1

or(逻辑或)	0	1
0	0	1
1	1	1

Python成员运算符

除了以上的一些运算符之外，python还支持成员运算符，测试示例中包含一系列的成员，包括字符串，列表或元组

运算符	描述	实例
in	如果在指定的序列中找到值返回True，否则返回False	x在y序列中，如果x在y序列中返回True
not in	如果在指定的序列中没有找到值返回True，否则返回False	x不在y的序列中，如果x不在y序列或者能够返回True

Python身份运算符

身份运算符用于比较两个对象的存储单元

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

注:id()函数用于获取对象内存地址

Python运算符的优先级

以下表格列出了从最高到最低优先级的所有运算符：

运算符	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 ‘AND’
^\
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符

数据类型的强制转换

强转类型	描述
int(x)	将x转换成一个整数
float(x)	将x转换成浮点数
int(x [,base ])	将x转换为一个整数
long(x [,base ])	将x转换为一个长整数
float(x )	将x转换到一个浮点数
complex(real [,imag ])	创建一个复数
str(x )	将对象 x 转换为字符串
repr(x )	将对象 x 转换为表达式字符串
eval(str )	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s )	将序列 s 转换为一个元组
list(s )	将序列 s 转换为一个列表
chr(x )	将一个整数转换为一个字符
unichr(x )	将一个整数转换为Unicode字符
ord(x )	将一个字符转换为它的整数值
hex(x )	将一个整数转换为一个十六进制字符串
oct(x )	将一个整数转换为一个八进制字符串
bin(x)	将一个整数转换为一个二进制字符串

关于进制

十进制	二进制	八进制	十六进制
0	0000 0000	0000 0000	0
1	0000 0001	0000 0001	1
2	0000 0010	0000 0002	2
3	0000 0011	0000 0003	3
4	0000 0100	0000 0004	4
5	0000 0101	0000 0005	5
6	0000 0110	0000 0006	6
7	0000 0111	0000 0007	7
8	0000 1000	0000 0010	8
9	0000 1001	0000 0011	9
10	0000 1010	0000 0012	A
11	0000 1011	0000 0013	B
12	0000 1100	0000 0014	C
13	0000 1101	0000 0015	D
14	0000 1110	0000 0016	E
15	0000 1111	0000 0017	F
16	0001 0000	0000 0020	0010

常见的数学函数

函数名	描述
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
fabs(x)	返回数字的绝对值，如math.fabs(-10) 返回10.0
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
round(x [,n])	返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,…)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,…)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
sqrt(x)	返回数字x的平方根
cmp(x, y)	存在于py2,如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1

• abs与fabs运行区别:
  • fabs()的使用需要导入数学模块(math),而abs()不需要
  • 返回数据类型不同

>>> a = abs(-9)
>>> b = fabs(-9)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'fabs' is not defined
>>> import math
>>> a = abs(-9)
>>> b = math.fabs(-9)
>>> a,type(a)
(9, <class 'int'>)
>>> b,type(b)
(9.0, <class 'float'>)

>>> import math
>>> dir(math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']
>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'math']
>>> from math import *
>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'math', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']

指数

1、正整数指数幂：实数a自乘n次得到的实数b，b=a×a×a ×a……×a, （n∈N，且 n >1）,称为实数a的n次幂，n为自然数，数a的n次幂用an表示，记作{\rm{b}} = {a^n}，数a称为幂的底，数n称为幂指数。注意：{\rm{b}} = {a^1}

• cmp()函数

  python2使用，python3已取消

  python3中对应的使用:

>>> import operator
>>> operator.eq("q","q") # eq:equal,判断是否相等
True
lt(a,b)相当于a<b  从第一个数字或字母(ASCII)比大小
>>> operator.lt("a","b") # lt:less than
True
>>> operator.le("a","a")
True
>>> operator.lt("a","a") # lt:less than
False

随机函数(random)

• 模块导入

#方法一
>>>import random
#方法二
>>>from random import * #不推荐使用

• 查看对应的方法和属性

>>>dir(random)
['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_BuiltinMethodType', '_MethodType', '_Sequence', '_Set', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_inst', '_itertools', '_log', '_pi', '_random', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', '_warn', 'betavariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate', 'paretovariate', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
>>>

• random模块常用的功能
  • random.random():用于随机生成一个0到1的浮点数n(0<=n<=1)

>>> import random
>>> nun = random.random()
>>> print(nun)
0.09095966637327513
>>> print(nun)  #在随机生成之后无论怎么打印这个数还是不会变
0.09095966637327513
>>> nun = random.random()
>>> print(nun)	#只能重新生成一个随机数才会改变
0.9659144361674479
>>>

• random.uniform(a,b):用于生成指定范围内的随机浮点数，两个参数，其中之一是上限，另一个是下限
  • 如果a>b,生成的随机数n:a<=n<=b;
  • 如果a<b,生成的随机数n:b<=n<=a;

>>> import random
>>> random.uniform(1,10)
4.238137852842515
>>> random.uniform(10,1)
1.5240380497388877

• random.randint(a,b):随机生成a到b范围内的整数n(a<= n <=b)

>>> random.randint(10,1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "D:\Python36\lib\random.py", line 221, in randint
    return self.randrange(a, b+1)
  File "D:\Python36\lib\random.py", line 199, in randrange
    raise ValueError("empty range for randrange() (%d,%d, %d)" % (istart, istop, width))
ValueError: empty range for randrange() (10,2, -8)
#括号内的数字只能从小到大，从大到小会报错
>>> random.randint(1,10)
3

• random.randrange([start],[stop],[step]):从指定范围内，按指定基数递增的集合中获取一个随机数。
  • 集合为(start,start+stop+2*step,···,start+n*step)

>>> random.randrange(10,30,2)
20 
>>> random.randrange(100,30,-2)
52

• random.choice(sequence):从序列中随机获取一个元素

>>> lst = ['python','C','C++','javascript']
>>> str1 = ('I love python')
>>> random.choice(lst)
'javascript'
>>> random.choice(lst)
'C'
>>> random.choice(str1)
'y'
>>> random.choice(str1)
'n'

• random.shuffle(x[ , random]):用于将一个列表中的元素打乱，即将列表内的元素随机排列

>>> p = ['A','B','C','D','E']
>>> random.shuffle(p)
>>> p
['C', 'E', 'A', 'D', 'B']

• random.sample(sequemce,k):从指定序列中获取指定长度的片段并随机排列。注意:sample函数不会修改原有序列。

>>> li = [1,2,3,4,5,6]
>>> random.sample(li,4)
[1, 6, 4, 5]
>>> random.sample(li,3)
[4, 1, 5]
>>> random.sample(li,2)
[2, 5]
>>> random.sample(li,5)
[6, 3, 1, 5, 4]

Python程序流程控制

• if…else

• while

• for

  C或者java，Switch…case,default，Python中则不存在

常见流程控制语句：

1. 顺序执行

2. 选择分支

3. 循环执行

   需要去注意的是，C或者java，通常用花括号{}来控制流程控制语句的语法，而Python 则使用缩进来控制相应的语法

>>> a = 2
>>> if a < 3:
...     print("a < 3")
...
a < 3

IF条件分之语句

Python条件语句是通过一条或多条语句执行结果(True或者False)来决定执行的代码块

• if单分支语句

if 逻辑语句:
    语句(块)

demo:

print(111)
if True:
	print(222)
print(333)	

结果:

111
222
333

修改条件:

print(111)
if False:
	print(222)
print(333)

结果:

111
333

将True或者False换成逻辑语句。

练习：随机生成一个数字，输入一个数字，比大小

import random
a = random.randint(1,10)
for i in range(10):
    b = int(input("输入数字"))
    if a < b:
        print("猜对了")
print("猜错了")

• if双分支语句

if 逻辑语句:
	语句(块)1
elif:
	语句(块)2

demo:

learning = "java"
if learning == "python"
	print("啊哈，真巧，我也在学习Python")
else:
	print("小明和你一样，他也在学习java")
print("很高兴认识你")	

练习:写一个登录判断

import getpass
username = input("请输入用户名:")
password = getpass.getpass("请输入密码:")
if username == "admin" and password == "123456":
    print("登陆成功")
else:
    print("请重试")

输入密码隐藏:getpass(在IDE中无法运行，只能在脚本中运行)

• if多分支语句

  Python中用elif代替了 else if，所以if语句的关键字为：if - elif - else。

  注意：

  1. 每个条件后面要使用冒号:，表示接下来是要满足条件后要执行的语句块
  2. 使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
  3. 在Python中没有switch - case语句。

if 逻辑语句:
    语句(块)1
elif 逻辑语句2:
    语句(块)2
elif 逻辑语句3:
    语句(块)3
    ......
elif 逻辑语句n-1:
    语句(块)n-1
else:
    语句(块)n

练习:

输入0~100看能到多少分

num = int(input("输入你要的数字:"))
if num == 100 :
    print("A+")
elif num > 100:
    print("比最高分还高是自己改的吧")
elif num >= 90:
    print("A")
elif num >= 80:
    print("B")
elif num >= 70:
    print("C")
elif num >= 60:
    print("D")
else :
    print("不及格")

while循环语句

• 概念：循环用来执行部分代码…即在一定的条件下执行重复的代码。
• 格式：

while 逻辑语句:
	语句(块)

demo:

1. 1-100

num = 0
while num < 100:
   num += 1
   print(num)

2.1-100的和:

num = 0
max = 0
while num < 100:
   num += 1
   max += num
print(max)

braek与continue

如果在循环的过程中，因为某些原因，你不想就像循环了，怎么把它终止掉呢？这就用到break或continue语句

• break用于完全结束一个循环，跳出循环体执行循环后面的语句
• continue和break有点类似，区别在于continue只是终止本次循环，接着还执行后面的循环，break则完全终止循环

例子 break

count = 0
while count <= 100:
	print("loop",count)
	if count == 5
		break
	count += 1

for循环

Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。

for循环格式：

for i in 序列:
	语句(块)

demo:

1. 遍历字符串

demo_str = "python"
for i in demo_str:
    print(i)

运行结果:

p
y
t
h
o
n

2.range()

range(end)
#[0,end)
range(start,end)
#[start,end)
range(start,end,step)
#{start,start+step,......,start + n*step}
(start + n*step)为[start,end)范围内的

for循环打印四行四列星号

for i in range(4):
    for j in range(4):
        print("*" , end = "")
    print()
    
#运行结果
"""
****
****
****
****
"""

字符串

什么是字符串

​ 字符串是Python中最常用的数据类型，我们可以在使用引号('或")来创建字符串，事实上，在Python中，加了引号的字符都被认为是字符串

​ Python中单个字符和多个字符用引号包裹后，统称为字符串，没有Java或者C中字符的说法

>>> name = "Tang you"
>>> age = "18"
>>> age_1 = 18
>>> msg = '''I'm Tang you''' #单引号会就近重合，使用三个单引号会避免 三单引号三双引号可以换行使用
>>> msg = """I'm Tang you"""
>>> print(type(name),type(age),type(age_1),type(msg))
<class 'str'> <class 'str'> <class 'int'> <class 'str'>

(3)字符串索引([]以及切片[::])

a = "Life is short, I use python"
print(len(a))
print(a[26])
print(a[8:10])
print(a[-19:-17])
print(a[::-1])

"""
27
n
sh
sh
nohtyp esu I ,trohs si efiL
"""

(4)大小写转换

• str.lower():转小写
• str.upper();转大写
• str.swapcase():大小写对换
• str.capitalize():字符串首为大写，其余小写
• str.title():已分隔为标记，首字符为大写，其余为小写

a = "Life is short, I use python"
print(a.lower()) # 将所有大写字符转换为小写
print(a.upper()) # 将所有小写字符转换为大写字符
print(a.swapcase()) # 将所有小写字符变成大写，将大写字符变成小写
print(a.capitalize()) # 将字符串的第一个字符大写
print(a.title()) # 返回标题化的字符

"""
life is short, i use python
LIFE IS SHORT, I USE PYTHON
lIFE IS SHORT, i USE PYTHON
Life is short, i use python
Life Is Short, I Use Python
"""

(5)字符串格式输出对齐

• str.center()
• str.ljust()
• str.rjust()
• str.zfill()

a = "Life is short, I use python"
print(a.center(30, '^')) # 居中对齐,并使用空格填充至长度
print(a.ljust(30, '^')) # 左对齐,并使用空格填充至长度
print(a.rjust(30, '^')) # 右对齐,并使用空格填充至长度
print(a.zfill(30,))

"""
^Life is short, I use python^^
Life is short, I use python^^^
^^^Life is short, I use python
000Life is short, I use python
"""

(6)删除指定字符

• str.lstrip()
• str.rstrip()
• str.strip()

a = "*****Life is short, I use python*****"
print(a.lstrip("*"))
print(a.rstrip("*"))
print(a.strip("*"))

"""
Life is short, I use python*****
*****Life is short, I use python
Life is short, I use python
"""

(7)计数

excel表中:

=COUNTIF(B2:B31,">=30")COUNT(B2:B31)

python中:

a = "Life is short, I use python"
print(a.count('i')) # 返回 str 在 string 里面出现的次数
print(a.count('i' , 4 , 8)) # 在索引值为[4,8)的范围内str出现的次数

"""
2
1
"""

(8)字符搜索定位与替换

• str.find()

a = "Life is short, I use python"
print(a.find('e')) # 查找元素并返回第一次出现的索引值
print(a.find('e' , 18 , 24)) # 查找元素在指定索引范围内的索引
print(a.find('w')) # 找不到值返回-1
"""
3
19
-1
"""

• str.index()
  • 和find()方法一样，只不过如果str不在string中会报一个异常。

a = "Life is short, I use python"
print(a.index('i'))
print(a.index('e' , 18))
print(a.index('c')) # 没有这个元素，会报异常
"""
1
19

Traceback (most recent call last):
  File "E:/Python/3.13.py", line 135, in <module>
    print(a.index('c'))
ValueError: substring not found
"""

• str.replace()
  • 替换

a = "Life is short, I use python"
print(a.replace('I use', 'You need'))
print(a.replace('t' , 'T'))
print(a.replace('t' , 'T' , 1))
"""
Life is short, You need python
Life is shorT, I use pyThon
Life is shorT, I use python
"""

字符串运算及操作

数字可以进行加减乘除的运算，字符串只可以进行"相加"和"相乘"运算

(1)拼接

a = "唐友"
b = "hello"
print(a + b)
"""
hello
"""

注意，字符串拼接只能是双方都是字符串，不能跟数字或其他类型拼接

b = "666"
c = 100
print(b + c)
"""
Traceback (most recent call last):
  File "E:/Python/3.13.py", line 145, in <module>
    print(b + c)
TypeError: must be str, not int
"""

(2)重复

a = "唐友"
b = "hello"
print(a + b * 3)

(3)字符串索引([]以及切片[::])

a = "**********Life is short, I use python"
print(len(a))
print(a[0])
print(a[15])
print(a[-1])
print(a[-6])
#切片
print(a[15::2])
print(a[::-1])
"""
37
*
i
n
p
i hr,Iuepto
nohtyp esu I ,trohs si efiL**********
"""

(9)字符串条件判断

• isalnum()，字符串由字母或数字组成，
• isalpha()，字符串只由字母组成，
• isdigit()，字符串只由数字组成

In [1]: a = "abc123"

In [2]: b = "ABC"

In [3]: c = 123

In [4]: a.isalnum()
Out[4]: True

In [5]: a.isalpha()
Out[5]: False

In [6]: a.isdigit()
Out[6]: False

In [7]: b.isalnum()
Out[7]: True

In [8]: b.isalpha()
Out[8]: True

In [9]: b.isdigit()
Out[9]: False>>> str = '01234'
 
>>> str.isalnum()   # 是否全是字母和数字，并至少有一个字符
True
>>> str.isdigit()    # 是否全是数字，并至少有一个字符
True      
 
 
>>> str = 'string'
 
>>> str.isalnum()  # 是否全是字母和数字，并至少有一个字符
True
>>> str.isalpha()  # 是否全是字母，并至少有一个字符 
True
>>> str.islower() # 是否全是小写，当全是小写和数字一起时候，也判断为True
True
 
>>> str = "01234abcd"
 
>>> str.islower() # 是否全是小写，当全是小写和数字一起时候，也判断为True
True
 
>>> str.isalnum()  # 是否全是字母和数字，并至少有一个字符
True
 
>>> str = ' '
>>> str.isspace()  # 是否全是空白字符，并至少有一个字符
True
 
>>> str = 'ABC'
 
>>> str.isupper()   # 是否全是大写，当全是大写和数字一起时候，也判断为True
True
 
>>> str = 'Aaa Bbb'
 
>>> str.istitle()  # 所有单词字首都是大写，标题 
True
 
 
>>> str = 'string learn'
 
>>> str.startswith('str') # 判断字符串以'str'开头
True
 
>>> str.endswith('arn')  # 判读字符串以'arn'结尾
True

(10)制表符转化
str.expandtabs()

>>> a = "L\tife is short, I use python"
>>> a.expandtabs() # 默认将制表符转化为8个空格
'L       ife is short, I use python'
>>> a.expandtabs(4) # 加上参数，将制表符转化为对应个数的空格
'L   ife is short, I use python'
>>>

(11)字符串分割变换

• join()将指定字符插入到元素之间
• split()以指定字符分隔序列且去除该字符
• partition()以指定字符分隔序列且包含该字符

>>> str = "learn string"
>>> '-'.join(str)
'l-e-a-r-n- -s-t-r-i-n-g'
>>> '+'.join(str)
'l+e+a+r+n+ +s+t+r+i+n+g'
>>> li = ["learn","string"]
>>> '-'.join(li)
'learn-string'
>>> str.split('n')
['lear', ' stri', 'g']
>>> str.split('n',1)
['lear', ' string']
>>> str.rsplit('n',1)
['learn stri', 'g']
>>> str.rsplit('n')
['lear', ' stri', 'g']
>>> str.splitlines()
['learn string']
>>> str.partition('n')
('lear', 'n', ' string')
>>> str.rpartition('n')
('learn stri', 'n', 'g')
>>>

补充:

string模块

查看:

>>> import string
>>> dir(string)
['Formatter', 'Template', '_ChainMap', '_TemplateMetaclass', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__',
 '__spec__', '_re', '_string', 'ascii_letters', 'ascii_lowercase', 'ascii_uppercase', 'capwords', 'digits', 'hexdigits', 'octdigits', 'printable', 'punctuation', 'whitespace']
>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'
>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.capwords('hUNAN yingxiao  college')
'Hunan Yingxiao College'
>>>

• string模块中的capwords()函数功能:
  • 1.将每个单词首字母至为大写
  • 2.将每个单词除首字母外的字母均置为小写
  • 3.将词与词之间的多个空格用一个空格代替
  • 4.其拥有两个参数，第二个参数用以判断单词之间的分割符，默认为空格

>>> import string
>>> string.digits
'0123456789'
>>> string.hexdigits
'0123456789abcdefABCDEF'
>>> string.octdigits
'01234567'
>>> string.printable
'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'
>>> string.punctuation
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
>>>

列表

列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：

li = [‘ex’,123,Ture,(1,2,3,’sir’),[1,2,3,’小明’,],{‘name’:’ex’}]

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

特点:是一个有序的，可以重复的序列，可变类型

1.创建一个空列表

list1 = []
print(type(list1))

2.创建一个有多个值的列表，每个值用逗号隔开。

list = [18,25,16,22,28]

列表页可以存放不同的类型元素。

lst2 = [18,"str",[1,2,3],(66,67),{'name':'Tom','age':18}]

列表索引和切片

>>> lst2 = [18,"str",[1,2,3],(66,67),{'name':'Tom','age':18}]
>>> len(lst2)
5
>>> lst2[0]
18
>>> lst2[3]
(66, 67)
>>> lst2[-1]
{'name': 'Tom', 'age': 18}
>>> lst2[3:]
[(66, 67), {'name': 'Tom', 'age': 18}]
>>> lst2[0::2]
[18, [1, 2, 3], {'name': 'Tom', 'age': 18}]
>>>

列表的常见操作

列表:

names = ['a','b','c','d']

1.增加

append(),extend(),insert()

• 1.append(),增加到最后

>>> names = ['a','b','c','d']
>>> names.append('e')
>>> names
['a', 'b', 'c', 'd', 'e']
>>> names = ['a','b','c','d']
>>> names.append([1,2,3])
>>> names
['a', 'b', 'c', 'd', [1, 2, 3]]
>>>

• 2.extend(),迭代的去增

>>> names = ['a','b','c','d']
>>> place = ['beijing','shangdong','usa']
>>> names.extend(place)
>>> names
['a', 'b', 'c', 'd',  'beijing', 'shangdong', 'usa']
>>>

• 3.insert(),按照索引去增加

>>> names = ['a','b','c','d']
>>> names.insert(2,'devilf')
>>> names
['a', 'b', 'devilf', 'c', 'd']
>>>

• 4.其他的插入方法

>>> names[3] = 'lebron'
>>> names
['a', 'b', 'devilf', 'lebron', 'd']
>>>

2.删除

pop、remove、del、clear

• 1.pop()

>>> names.pop() # 没有指定索引时，默认删除最后一个元素
'usa'
>>> names
['a', 'b', 'devilf', 'lebron', 'd', [1, 2, 3], 'beijing', 'shangdong']
>>> names.pop(2) # 指定索引时，就会删除索引所对应的元素
'devilf'
>>> names
['a', 'b', 'lebron', 'd', [1, 2, 3], 'beijing', 'shangdong']
>>>

• 2.remove(),按照元素删除

>>> names.remove('b')
>>> names
['a', 'lebron', 'd', [1, 2, 3], 'beijing', 'shangdong']
>>>

• 3.del

>>> del names[4]
>>> names
['a', 'lebron', 'd', [1, 2, 3], 'shangdong']
>>>

• 4.clear()

>>> names.clear()
>>> names
[]
>>>

3.改

>>> li = ['a','b','c','d']
>>> li[1] = 'cc'
>>> li
['a', 'cc', 'c', 'd']
>>> li[0:2] = ['aa','bb']
>>> li
['aa', 'bb', 'c', 'd']

4.查

切片去查，或者，循环去查

• 索引，切片，遍历

1.查找元素所在位置:index()

>>> names = ['a','b','c','d']
>>> names.index('c')
2
>>>

• 遍历

两种:

(1)

>>> li = ['python','Java','C++']
>>> for i in li:
...     print(i,end = " ")
...
python Java C++ >>>

(2)

>>> li = ['python','Java','C++']
>>> for i in range(len(li)):
...     print(li[i],end = " ")
...
python Java C++ >>>

5.其他操作

1.统计元素的次数:count()

>>> names = ['a', 'b', 'c', 'd']
>>> names.append('d')
>>> names.count('d')
2
>>>

2.反转：reverse()

>>> names = ['a', 'b', 'c', 'd']
>>> names.reverse()
>>> names
['d', 'd', 'c', 'b', 'a']

3.排序：sort()按照ascii码来进行排序

>>> names = ['d', 'd', 'b', 'a']
>>> names.insert(3,'&&')
>>> names
['d', 'd', 'c', '&&', 'b', 'a']
>>> names.sort()
>>> names
['&&', 'a', 'b', 'c', 'd', 'd']
>>> names.sort(reverse=True)
>>> names
['d', 'd', 'c', 'b', 'a', '&&']
>>> names[::-1]
['&&', 'a', 'b', 'c', 'd', 'd']
>>>

索引与元素同时遍历

>>> li = ['python','Java','C++']
>>> for i, li[i] in enumerate(li):
...     print(i,li[i])
...
0 python
1 Java
2 C++
>>>

Python字符串格式化

尽管已经掌握了所介绍的字符串方法和序列操作，Python还提供了一种更高级的方法来组合字符串处理任务——字符串格式化允许在一个单个的步骤中对一个字符串执行多个特定类型的替换。它不是严格必须的，但它很方便使用，特别是当格式化文本以显示给程序的用户的时候。由于Python世界中充满了很多新思想，如今的Python中的字符串格式化可以以两种形式实现：

• 字符串格式化表达式
  这是从Python诞生的时候就有的最初的技术；这是基于C语言的“printf”模型，并且在大多数现有的代码中使用。
• 字符串格式化方法调用
  这是Python2.6和Python3.0新增加的技术，这是Python独有的方法，并且和字符串格式化表达式的功能有很大重叠。

由于方法调用是很新，其中的某些或另外一些可能会随着时间的推移而废弃。表达式更有可能在以后的Python版本中废弃，尽管这应该取决于真正的Python程序员未来的实际使用情况。然而，由于它们很大程度上只是同一个方案的变体，现在这两种技术都是有效的。既然字符串格式化表达式是最初的方法，让我们从它开始。

Python在对字符串操作的时候定义了%二进制操作符（你可能还记得它在对数字应用时，是除法取余数的操作符）。当应用在字符串上的时候，%提供了简单的方法对字符串的值进行格式化，这一操作取决于格式化定义的字符串。简而言之，%操作符为编写多字符串替换提供了一种简洁的方法，而不是构建并组合单个的部分。

格式化字符串

• 1.在%操作符的左侧放置一个需要进行格式化的字符串，这个字符串带有一个或多个嵌入的转换目标，都以%开头（例如，%d）。
• 2.在%操作符右侧放置一个（或多个，嵌入到元组中）对象，这些对象将会插入到左侧想让Python进行格式化字符串的一个（或多个）转换目标的位置上去。

例如，在下列一个格式化示例中，整数1替换在格式化字符串左边的%d，字符串‘bird’替换%s。结果就得到了一个新的字符串，这个字符串就是这两个替换的结果：

>>> print("No. %d:\tI'm a little little %s." % (1, "bird"))
No. 1:  I'm a little little bird.
>>>

从技术上来讲，字符串的格式化表达式往往是可选的一—通常你可以使用多次的多字符串的合并和转换达到类似的目的。然而格式化允许我们将多个步骤合并为一个简单的操作，这一功能相当强大，我们多举几个例子来看一看：

>>> say = "Hello"
>>> "Hello - %s" % say
'Hello - Hello'
>>> "%d %s %d %s" % (2, "hand", 2, "eye")
'2 hand 2 eye'
>>> "%s -- %s -- %s" % (3.14, 'pi', '山巅一寺一壶酒')
'3.14 -- pi -- 山巅一寺一壶酒'
>>>

在第一个例子中，在左侧目标位置插入字符串"Hello"，代替标记%s。在第二个例子中，在目标字符串中插入三个值。需要注意的是当不止一个值待插入的时候，应该在右侧用括号把它们括起来（也就是说，把它们放到元组中去）。%格式化表达式操作符在其右边期待一个单独的项或者一个或多个项的元组。
　　第三个例子同样是插入三个值：一个整数、一个浮点数对象和一个列表对象。但是注意到所有目标左侧都是%s，这就表示要把它们转换为字符串。由于对象的每个类型都可以转换为字符串（打印时所使用的），每一个与%s一同参与操作的对象类型都可以转换代码。正因如此，除非你要做特殊的格式化，一般你只需要记得用%s这个代码来格式化表达式。
　　另外，请记住格式化总是会返回新的字符串作为结果而不是对左侧的字符串进行修改；

由于字符串是不可变的，所以只能这样操作。如前所述，如果需要的话，你可以分配一个变量名来保存结果。

Python字符串格式化

尽管已经掌握了所介绍的字符串方法和序列操作，Python还提供了一种更高级的方法来组合字符串处理任务——字符串格式化允许在一个单个的步骤中对一个字符串执行多个特定类型的替换。它不是严格必须的，但它很方便使用，特别是当格式化文本以显示给程序的用户的时候。由于Python世界中充满了很多新思想，如今的Python中的字符串格式化可以以两种形式实现：

• 字符串格式化表达式
  这是从Python诞生的时候就有的最初的技术；这是基于C语言的“printf”模型，并且在大多数现有的代码中使用。
• 字符串格式化方法调用
  这是Python2.6和Python3.0新增加的技术，这是Python独有的方法，并且和字符串格式化表达式的功能有很大重叠。

由于方法调用是很新，其中的某些或另外一些可能会随着时间的推移而废弃。表达式更有可能在以后的Python版本中废弃，尽管这应该取决于真正的Python程序员未来的实际使用情况。然而，由于它们很大程度上只是同一个方案的变体，现在这两种技术都是有效的。既然字符串格式化表达式是最初的方法，让我们从它开始。

Python在对字符串操作的时候定义了%二进制操作符（你可能还记得它在对数字应用时，是除法取余数的操作符）。当应用在字符串上的时候，%提供了简单的方法对字符串的值进行格式化，这一操作取决于格式化定义的字符串。简而言之，%操作符为编写多字符串替换提供了一种简洁的方法，而不是构建并组合单个的部分。

格式化字符串

• 1.在%操作符的左侧放置一个需要进行格式化的字符串，这个字符串带有一个或多个嵌入的转换目标，都以%开头（例如，%d）。
• 2.在%操作符右侧放置一个（或多个，嵌入到元组中）对象，这些对象将会插入到左侧想让Python进行格式化字符串的一个（或多个）转换目标的位置上去。

例如，在下列一个格式化示例中，整数1替换在格式化字符串左边的%d，字符串‘bird’替换%s。结果就得到了一个新的字符串，这个字符串就是这两个替换的结果：

>>> print("No. %d:\tI'm a little little %s." % (1, "bird"))
No. 1:  I'm a little little bird.
>>>

从技术上来讲，字符串的格式化表达式往往是可选的一—通常你可以使用多次的多字符串的合并和转换达到类似的目的。然而格式化允许我们将多个步骤合并为一个简单的操作，这一功能相当强大，我们多举几个例子来看一看：

>>> say = "Hello"
>>> "Hello - %s" % say
'Hello - Hello'
>>> "%d %s %d %s" % (2, "hand", 2, "eye")
'2 hand 2 eye'
>>> "%s -- %s -- %s" % (3.14, 'pi', '山巅一寺一壶酒')
'3.14 -- pi -- 山巅一寺一壶酒'
>>>

在第一个例子中，在左侧目标位置插入字符串"Hello"，代替标记%s。在第二个例子中，在目标字符串中插入三个值。需要注意的是当不止一个值待插入的时候，应该在右侧用括号把它们括起来（也就是说，把它们放到元组中去）。%格式化表达式操作符在其右边期待一个单独的项或者一个或多个项的元组。
　　第三个例子同样是插入三个值：一个整数、一个浮点数对象和一个列表对象。但是注意到所有目标左侧都是%s，这就表示要把它们转换为字符串。由于对象的每个类型都可以转换为字符串（打印时所使用的），每一个与%s一同参与操作的对象类型都可以转换代码。正因如此，除非你要做特殊的格式化，一般你只需要记得用%s这个代码来格式化表达式。
　　另外，请记住格式化总是会返回新的字符串作为结果而不是对左侧的字符串进行修改；

由于字符串是不可变的，所以只能这样操作。如前所述，如果需要的话，你可以分配一个变量名来保存结果。

表：字符串格式化代码

代码	意义
s	字符串（或任何对象）
r	s，但使用repr，而不是str
c	字符
d	十进制（整数）i整数
u	无号（整数）八进位整数
o	八进制整数
x	十六进制整数
X	x，但打印大写
e	浮点指数
E	e，但打印大写
f	浮点十进制
F	浮点十进制
g	浮点e或f
G	浮点E或f
%	常量%

demo:名片打印

要求：输入姓名、年龄、工作和爱好，按下列格式输出：

---info of Linus---
Name : Linus
Age : 18
job : IT
Hobbie : Read
---------end---------

Format格式化(匹配花括号({}))

位置映射

>>> str = "{} 唱歌好听, \n {}唱歌更好听".format("唐友","周亮")
>>> str
'唐友 唱歌好听, \n 周亮唱歌更好听'

>>> "{}---{}---{}".format("木友","井友","河友")
'木友---井友---河友'

关键字映射

>>> "{0}---{name}---{1}".format("木友","水友",name = "河友")
'木友---河友---水友'
>>> "{0}---{name}---{1}".format(("木友","水友"),name = "河友")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
>>> "{0[0]}---{name}---{0[1]}".format(("木友","水友"),name = "河友")
'木友---河友---水友'
>>> "{0[0]}---{name}---{0[1]}".format(["木友","水友"],name = "河友")
'木友---河友---水友'
>>> "{name}:{age}".format(name = "唐友", age = "19")
'唐友:19'
>>> "{0[0]}---{0[1]}---{1[0]}---{1[1]}".format((1,2),(3,4))
'1---2---3---4'

元组

元组:

是一个有序的，可重复的，不可更改的对象;

特点:
	1.与list类似;
	2.不可变类型数据;
	3.元组使用的是()

元组的基本使用格式:

(元素1,元素2,......,元素n)

基本描述:

​ 元组使用()包裹起来的多个元素的数据类型,每个元素之间用","隔开

​ ,隔开返回的是两个元祖

1.元祖的创建

• 创建一个空元祖

>>> t1 = ()
>>> type(t1)
<class 'tuple'>
>>> st1 = tuple()
>>> t1,st1
((), ())
>>> type(t1),type(st1)
(<class 'tuple'>, <class 'tuple'>)

• 创建只含有一个元素的元组

需要注意的地方是,如果我们创建只含有一个元素的元组,我们必须在这仅有的一个元素后加上一个","

>>> t1 = (6)
>>> t1,type(t1)
(6, <class 'int'>)


>>> t1 = (6,) # 只有一个元素的元组，必须加上","
>>> t1,type(t1)
((6,), <class 'tuple'>)

• 创建含有多个元素的元组

>>> t1 = ("水友","井友","溪友","河友","海友")

和列表一样，元祖的元素也可以是不同的数据类型的元素。

>>> t1 = (1,"hunan",['h','u','n','a','n'],('I','love','python'),{"name":"tom","age":18})

2.元组的基本操作

查

• 通过索引值查找对应的元素

>>> t1 = (1,"hunan",['h','u','n','a','n'],('I','love','python'),{"name":"tom","age":18})
>>> t1[4]
{'name': 'tom', 'age': 18}
>>> t1[-1]
{'name': 'tom', 'age': 18}
>>> t1[::-2]
({'name': 'tom', 'age': 18}, ['h', 'u', 'n', 'a', 'n'], 1)

• 查找元素的索引值

>>> t1 = (1,"hunan",['h','u','n','a','n'],('I','love','python'),{"name":"tom","age":18})
>>> t1.index("hunan")
1

注意:元组是不可变的数据类型，不能够增,删,改

>>> t1 = (1,"hunan",['h','u','n','a','n'],('I','love','python'),{"name":"tom","age":18})
>>> t1[0] = 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

注意到t1里面有个列表，那么这个列表中的元素是否可以更改？

>>> t1 = (1,"hunan",['h','u','n','a','n'],('I','love','python'),{"name":"tom","age":18})
>>> t1[2]
['h', 'u', 'n', 'a', 'n']
>>> t1[2][2]
'n'
>>> t1[2][2] = 'N'
>>> t1
(1, 'hunan', ['h', 'u', 'N', 'a', 'n'], ('I', 'love', 'python'), {'name': 'tom', 'age': 18})

拼接

>>> t1 = ('a','b','c')
>>> t2 = ('d','e','f')
>>> t1 + t2
('a', 'b', 'c', 'd', 'e', 'f')

重复

>>> t1 * 3
('a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c')

判断元素是否存在

>>> t1 = ('a','b','c')
>>> 'a' in t1
True
>>> 'a' not in t1
False

内置函数(最大值最小值)

>>> t1 = ('a','b','c')
>>> max(t1)
'c'
>>> min(t1)
'a'

元组的遍历

1.值遍历

tp = ('Python','Java','C++')
for i in tp:
	print(i,end = " ")
# Python Java C++

2.索引遍历

>>> t1 = ('a','b','c')
>>> for i in range(len(t1)):
...     print(t1[i])
...
a
b
c

3.索引值，遍历

枚举(enumerate),对于一个可迭代的(iterable)/可遍历的对象(如列表、字符串)enumerate将其组成一个索引序列，利用它可以同时获得索引和值

>>> tp = ('Python','Java','C++')
>>> for index, value in enumerate(tp):
...     print(index, ':', value)
...
0 : Python
1 : Java
2 : C++

>>> for index, value in enumerate(tp,6):
...     print(index, ':', value)
...
6 : Python
7 : Java
8 : C++

字典

思考：

场景1

如果有列表

python  li = ['Pyhton', 'Java', 'C++'];

需要对"pyhton"这个名字写错了，通过代码修改：

python  li[0] = "Python"

如果列表的顺序发生了变化，如下

python  li = ['Java', 'C++', 'Pyhton'];

此时就需要修改下标，才能完成名字的修改

python  li[2] = "Python"

有没有方法，既能存储多个数据，还能在访问元素的很方便就能够定位到需要的那个元素呢？

答：

​ 字典

场景2：

学生信息列表，每个学生信息包括学号、姓名、年龄等，如何从中找到某个学生的信息？

```Python

studens = [[201801, “张三”, 18], [201802, “李四”, 19], [201803, “王二”，17], …]
 ```

循环遍历？ 这样很麻烦。

实际生活中，我们还经常使用汉语字典，英汉词典等等。

程序中的字典：

info = {"username":"Lilei","age":18,"Class":"one"}

​ 字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。字典是一种可变的数据类型。且可存储任意类型对象。列表是有序的对象结合，字典是无序的对象结合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

格式:
	{key1:value1,key2:value2,......}

描述：

​ 1.键-值对中间用冒号(":")连接；

​ 2.key:value组成字典里的元素；

​ 3.键-值对(元素)之间用逗号(",")隔开；

​ 4.整个字典用花括号"{}"包裹起来。

字典的创建

创建一个空字典

>>> dic = {}
>>> type(dic)
<class 'dict'>

创建一个有多个值的字典

1.直接赋值法：d = {key1:value1,key2:value2}，如

1.
>>> info = {"username":"Lilei","age":18,"Class":"one"}
>>> info
{'username': 'Lilei', 'age': 18, 'Class': 'one'}

拓展:

>>> key1 = "name"
>>> key2 = "age"
>>> value1 = "Tom"
>>> value2 = 18
>>> d = {key1:value1,key2:value2}
>>> d
{'name': 'Tom', 'age': 18}

2.通过函数创建字典(强制转换)：

# 法1
>>> info = dict(usrname = "Lilei", age = 18, Class = "one")
>>> info
{'usrname': 'Lilei', 'age': 18, 'Class': 'one'}
# 法2
>>> info = dict([['name', 'LiLei'], ['age', 18]])
>>> info
{'name': 'LiLei', 'age': 18}
# 法3
>>> info = dict((('name', 'LiLei'), ('age', 18)))
>>> info
{'name': 'LiLei', 'age': 18}
# 法4
>>> info = dict([('name', 'LiLei'), ('age', 18)])
>>> info
{'name': 'LiLei', 'age': 18}
# 法5
>>> info = dict((['name', 'LiLei'], ['age', 18]))
>>> info
{'name': 'LiLei', 'age': 18}

3.通过字典的fromkeys方法创建字典

>>> info = dict.fromkeys("Hello") # 如果没有指定默认值，默认为 None
>>> info
{'H': None, 'e': None, 'l': None, 'o': None}
>>> info = dict.fromkeys(["Lilei","Lee","Jack"],"123456") # 给每个元素设置默认值为"123456";
>>> info
{'Lilei': '123456', 'Lee': '123456', 'Jack': '123456'}

字典的常见操作

字典值的访问(查的一种)

字典是无序的，不是通过索引值来获取值。

>>> info = info[2]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 2

• 通过键(key)访问值(value)
  • key值不存在的时候，会报错

>>> info = {"username":"Lilei","age":18,"Class":"one"}
>>> info["username"] # 通过关键字访问对应的值
'Lilei'
>>> info["age"]
18
>>> info["ysername"] 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'ysername'

• 使用get访问值(value)

  不确定字典中是否存在某个键而又想获取值时，可以使用get方法，还可以设置默认值

  • 当key不存在的，不会抛出异常，返回None

>>> info = {"name":"Lilei","age":18}
>>> info.get("name")
'Lilei'
# 当key不存在的，不会抛出异常，返回None
>>> info.get("job")
>>> type(info.get("job"))
<class 'NoneType'>

增

• 直接添加新键-值对

  在使用变量名[‘键’] = 数据时,这个"键"在字典中,不存在，那么就会新增这个元素:

>>> info["job"] = "IT"
>>> info
{'name': 'Lilei', 'age': 18, 'job': 'IT'}

• dict.update()

  把字典info1的键/值对更新到info里

  • 当两个字典中的键不同时，把info1的键值插入到info中
  • 当两个字典中存在相同键时，info1覆盖info的键值

# 当两个字典完全不相同时
>>> info = {"name":"Lilei","age":18}
>>> info1 = {"job":"IT","salary":10000}
>>> info.update(info1)
>>> info
{'name': 'Lilei', 'age': 18, 'job': 'IT', 'salary': 10000}
>>> info1
{'job': 'IT', 'salary': 10000}
>>>
# 当两个字典存在相同键时，会覆盖前面的键值
>>> info = {"name":"Lilei","age":18}
>>> info1 = {"name":"Tom","salary":10000}
>>> info.update(info1)
>>> info
{'name': 'Tom', 'age': 18, 'salary': 10000}
>>> info1
{'name': 'Tom', 'salary': 10000}

删

• del dict[keys]
  • 删除指定的元素键/值对
  • 没有返回值

>>> info = {"name":"Lilei","age":18}
>>> del info["name"]
>>> info
{'age': 18}

• del dict
  • 删除整个字典

>>> info = {"name":"Lilei","age":18}
>>> del info

• dict.clear()
  • 清空整个字典

>>> info = {"name":"Lilei","age":18}
>>> info.clear()
>>> info
{}

• dict.pop(keys)
  • 删除指定键/值对

>>> info = {'name': 'Tom', 'age': 18, 'salary': 10000}
>>> info.pop("age")
18
>>> info
{'name': 'Tom', 'salary': 10000}

• dict.popitem()
  • 随即删除字典中的一组键值对
  • 有返回值，以元组的方式返回
  • 应用不广泛

>>> info = {'name': 'Tom', 'age': 18, 'salary': 10000}
>>> info.popitem()
('salary', 10000)
>>> info
{'name': 'Tom', 'age': 18}

改

字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改

• 直接修改

>>> info = {'name': 'Tom', 'age': 18, 'salary': 10000}
>>> info["name"] = "Lilei"
>>> info
{'name': 'Lilei', 'age': 18, 'salary': 10000}

• dict.setdefault()
  • 键存在，不改动，返回字典中相应的值
  • 键不存在，在字典中添加相应的键值对，并返回相应的值

# 键存在，不改动，返回字典中相应的值
>>> info = {'name': 'Tom', 'age': 18, 'salary': 10000}
>>> info.setdefault("age",20) # 有返回值
18
>>> info
{'name': 'Tom', 'age': 18, 'salary': 10000}

# 键不存在，在字典中添加相应的键值对，并返回相应的值
>>> info = {'name': 'Tom', 'age': 18, 'salary': 10000}
>>> info.setdefault("job","IT")
'IT'
>>> info
{'name': 'Tom', 'age': 18, 'salary': 10000, 'job': 'IT'}

查

• dict.keys()
  • 返回字典中的所有键(key)
• dict.values()
  • 返回字典中的所有键(value)
• dict.items()
  • 返回字典中的所有键-值对(keys-values)
• 某元素是否存在：
  • key in dict
    • 存在，True
    • 不存在，False

>>> info = {'name': 'Tom', 'age': 18, 'salary': 10000}
>>> info.keys()
dict_keys(['name', 'age', 'salary'])

>>> info.values()
dict_values(['Tom', 18, 10000])

>>> info.items()
dict_items([('name', 'Tom'), ('age', 18), ('salary', 10000)])

>>> "age" in info
True

>>> "job" in info
False

字典的遍历

(1)遍历字典的键(key)

>>> info = {"username":"Lilei","age":18,"Class":"one"}
>>> for key in info.keys():
...     print(key,end = " ")
username age Class 

(2)遍历字典的值(value)

>>> info = {"username":"Lilei","age":18,"Class":"one"}
>>> for value in info.values():
...     print(value,end = " ")
Lilei 18 one 

(3)遍历字典所有的项(items)

>>> info = {"username":"Lilei","age":18,"Class":"one"}
>>> for item in info.items():
...     print(item,end = " ")
('username', 'Lilei') ('age', 18) ('Class', 'one') 

(4)遍历字典的键值对

>>> info = {"username":"Lilei","age":18,"Class":"one"}
>>> for key,value in info.items():
...     print(key,":",value,end = " ")
username : Lilei age : 18 Class : one 

集合

集合是无序的，不重复的且不可以更高的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希(所以集合做不了字典的键)的。以下是集合最重要的两点：

• 去重，把一个列表变成集合，就自动去重了。
• 关系测试，测试两组数据之前的交集、差集、并集等关系。

集合的创建

创建一个空的集合

这里需要注意，我们不可以直接用花括号"{}"

>>> st = set()
>>> st
set()
>>> st1 = {}
>>> type(st),type(st1)
(<class 'set'>, <class 'dict'>)

多元素的集合创建

>>> st = {"a","b","c","d","e"}
>>> st,type(st)
({'a', 'b', 'c', 'e', 'd'}, <class 'set'>)
>>> st = {1,2,3,[1,2]} # 列表是可变类型，所以会报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> st = {1,2,3,{"age":18}} # 列表可变
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'dict'
>>> st = {1,2,3,(1,2)} # 元组是不可变类型，所以不会报错
>>> st
{(1, 2), 1, 2, 3}

集合的强转

>>> li = [1,"a","n","University"]
>>> st_li = set(li)
>>> st_li,type(st_li)
({'n', 1, 'University', 'a'}, <class 'set'>)

>>> str = "Universitysity"
>>> st_str = set(str)
>>> st_str,type(st_str)
({'n', 'r', 's', 'v', 'U', 't', 'y', 'i', 'e'}, <class 'set'>)

>>> dic = {"a":1,"b":2,"c":3,"d":4}
>>> st_dic = set(dic)
>>> st_dic,type(st_dic)
({'c', 'b', 'a', 'd'}, <class 'set'>)

集合的基本操作

查

• 无序，不可查找

>>> st = {1,2,"Hunan","Yingxiao","College"}
>>> st[2]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support indexing

增

• set.add()
• set.update()

>>> st = {1,2,"Hunan","Yingxiao","College"}
>>> st.add("Computer Science")
>>> st
{1, 2, 'Computer Science', 'College', 'Yingxiao', 'Hunan'}
>>> st.update("湖南","长沙")
>>> st
{1, 2, '湖', '长', 'Computer Science', '南', 'College', 'Yingxiao', 'Hunan', '沙'}

删

• set.pop()
• set.discard()
• set.remove()

>>> st = {1,2,"Hunan","Yingxiao","College"}
>>> st.pop() # 删除排序最小的一个元素
1
>>> st
{2, 'College', 'Yingxiao', 'Hunan'}

>>> st = {1,2,"Hunan","Yingxiao","College"}
>>> st.discard(2) # 移除元素
>>> st
{1, 'College', 'Yingxiao', 'Hunan'}
>>> st.discard("HUNAN")　# 如果元素不存在，不会报错，不做任何操作
>>> st
{1, 'College', 'Yingxiao', 'Hunan'}

>>> st = {1,2,"Hunan","Yingxiao","College"}
>>> st.remove(2) # 删除指定元素，如果元素不存在就会报错
>>> st
{1, 'College', 'Yingxiao', 'Hunan'}
>>> st.("HUNAN")
  File "<stdin>", line 1
    st.("HUNAN")
       ^
SyntaxError: invalid syntax

• set.clear()
• del set名

>>> st = {1,2,3}
>>> st.clear()
>>> st
set()
>>> st = {1,2,3}
>>> del st
>>> st
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'st' is not defined

改，不可更改

>>> st = {1,2,3}
>>> st[0] = "Hunan"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support item assignment

遍历

>>> st = {1,2,"Hunan","Yingxiao","College"}
>>> for i in st:
...     print(i,end = " ")
...
1 2 College Yingxiao Hunan

>>> st = {1,2,"Hunan","Yingxiao","College"}
>>> for index,value in enumerate(st):
...     print(index,value)
...
0 1
1 2
2 College
3 Yingxiao
4 Hunan

比较

集合的基本运算

子集

>>> a = set("abcd")
>>> b = set("cdef")
>>> c = set("ab")
>>> a,b,c
({'c', 'b', 'a', 'd'}, {'c', 'f', 'e', 'd'}, {'b', 'a'})
>>> c.issubset(a)
True
>>> c < a
True
>>> c < b
False

交集

>>> a = set("abcd")
>>> b = set("cdef")
>>> a.intersection(b)
{'c', 'd'}
>>> a & b
{'c', 'd'}

并集

>>> a = set("abcd")
>>> b = set("cdef")
>>>a.union(b)
{'b', 'f', 'a', 'd', 'c', 'e'}
>>>a|b
{'b', 'f', 'a', 'd', 'c', 'e'}

差集

>>> a = set("abcd")
>>> b = set("cdef")
>>>a.difference(b)
{'a', 'b'}
>>>a-b
{'a', 'b'}

函数

• 数学意义上的函数
  • y=2x+1，y|_{x=3}=2×3+1=7
• 编程意义上的函数

python中函数的定义：函数是逻辑结构化和过程化的一种编辑方式

函数是可以重复使用的程序段，在开发程序中，需要某代码块多次，但是为了提高编写的效率以及代码的重用，所以把具有独立功能的代码块组织为一个小模块，这就是函数。

他们允许你给一块语句一个名称，然后你可以在你的程序的任何地方使用这个名称任意多次的运行这个语句块，这被称为 调用函数 ，我们已经使用了许多内建的函数，比如len()和range()。

函数的定义和调用

函数定义

• 空函数

如果定义一个事也不做的空函数，可以使用 pass 语句：

def func():
    pass

pass 语句什么都不做，那有什么用？实际上 pass 可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个 pass ，让代码能运行起来。

• 非空函数

函数通过def关键字定义，def关键字后跟一个函数的 标识符 名称 ，然后跟一对圆括号，圆括号之中可以包括一些变量名，该行以圆括号结尾。接下来是一块语句，它们是函数体。

声明函数的一般形式如下:

def 函数名(参数列表):
    '''说明'''
    函数语句
    return 返回值

说明如下：

​ 1.函数代码块以 def 关键字开头，后接函数标识符名称和小括号()。

​ 2.任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数

​ 3.函数的第一行语句可以选择性地使用文档字符串-----用于存放函数说明。

​ 4.函数内容以冒号起始，并且缩进。

​ 5.return[表达式]结束函数，选择性的返回一个值给调用方，不带表达式的return相当于返回None。其中参数列表和返回值不是必须的，return后也可以不跟返回值，甚至连 return 也没有。对于 return 后没有返回值的和没有return语句的函数都会返回None值，有些函数可能既不需要传递参数，也没有返回值。没有参数时，包含参数的圆括号也必须写上，圆括号后也必须有":"。

def info():
	"""打印信息"""
	print("name":"Tom","age":18)
info()

函数调用

函数定义后，我们就具备了实现某种功能的代码。执行这些代码， 只需要调用函数。

函数的调用形式

函数名()

比如上面我们已经定义好了info()函数，现在我们调用:

info()

现在整体写出代码:

# 定义函数
def info():
    """打印信息"""
    print({"name":"Tom","age":18})
# 调用函数
info()

运行，结果为：

{"name":"Tom","age":18}

函数文档说明

在上面代码的基础上，添加

help(info)

运行后，结果为

Help on function info in module _main_:
    
info()
	打印信息

可以看到，help()返回info()函数的相关说明。

直接查看文档说明

print(info._doc_)
# 打印信息

函数参数

假如我们定义一个函数计算两个数的积，有人设计如下函数:

def mul():
	x = 3
    y = 3
    print(x * y)
mul() # 9

这样可以吗？

这个函数只能实现3*3的效果，并不具备通用性。

为了让这个函数更具通用性，我们可以添加参数：

def mul(x,y):
    print(x * y)
mul(3, 6) # 调用

• 参数调用的顺序

我们可以先看一下以下例子：

>>> def test(x, y):
...     print(x)
...     print(y)
...
>>> test(x = 1, y = 2)
1
2
>>> test(y = 2, x = 1)
1
2
>>> test(1, y = 2)
1
2
>>> test(x = 1, 2)
  File "<stdin>", line 1
SyntaxError: positional argument follows keyword argument

函数返回值

这里形象的解释一下函数：函数就是把一堆代码，打包放在那里， 比如说一个发邮件的功能，然后这个 功能被调用，说到这里大家应该会想知道，我们调了，但是调的一个结果是啥？有没有成功？如果成功，干A的事，如果不成功做B的事情。

返回值的定义：函数外部的代码要想获得函数的执行结果，就可以 在函数里调用return语句把结果返回。

函数参数种类

首先，了解两个概念：形参合实参

• 1.形参：
  • 只有在被调用时才分配内存单元， 在调用结束时，即可释放所分配的内存单元，因此，形参只在函数内部有效，函数调用结束返回主调用函数后则不能再使用该形参变量；
• 2.实参：
  • 实参可以是常量，变量，表达式，函数等，无论实参是何种类型的量， 在进行函数调用时，他们都必须有确定的值，一边把这些值传给形参，因此应预先用赋值， 输入等办法是参数获得确定值；

>>> def test(x, y):
...     print(x)
...     print(y)
...
>>> test(1, 2) # 1, 2 ---> 实参
1
2

• 形参就是一把椅子，放在这里，占个位置而已，直到有人调用，赋值的时候才会分配内存单元，在调用时结束，即可释放；
• 实参，就是实实在在，什么类型都接受；

1.位置参数

def user_manger(name, age, job, hobby):
    print("用户管理系统".center(16, '-'))
    print("\tName",name)
    print("\tAge",age)
    print("\tJob",job)
    print("\tHobby",hobby)
    print("用户管理系统".center(16, '-'))
user_manger('Tom', 22 , 'IT' , 'Read')
user_manger('Lilei', 23 , 'IT' , 'Sing')
user_manger('Jim' , 21 , 'IT' , 'Dance')

位置参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样

2.默认值参数

假如我们设置hobby值为默认，即hobby = “Coding”。

def user_manger(name, age, job, hobby = "Coding"):
    print("用户管理系统".center(16, '-'))
    print("\tName",name)
    print("\tAge",age)
    print("\tJob",job)
    print("\tHobby",hobby)
    print("用户管理系统".center(16, '-'))
user_manger('Lucy', 21, "It") # 不传入参数，即为默认值。
user_manger('Tom', 22 , 'IT' , 'Read') # 传入参数，则改变值
user_manger('Lilei', 23 , 'IT' , 'Sing') # 传入参数，则改变值

通过观察，可知:

如果定义默认参数，在调用的时候，不给实参， 就会调用默认参数

如果函数定义修改为：

def user_manger(name, age, hobby = "Coding", job):

运行将报错：

def user_manger(name, age, hobby = "Coding", job):
                   ^
SyntaxError: non-default argument follows default argument

因此，默认参数必须要放到位置参数后边；

3.关键字参数

正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参致，只需指定参数名即可(指定了参数名的参数就叫关键参数)。

def user_manger(name, age, job = "IT", hobby = "Coding"):
    print("用户管理系统".center(16, '-'))
    print("\tName",name)
    print("\tAge",age)
    print("\tJob",job)
    print("\tHobby",hobby)
    print("用户管理系统".center(16, '-'))
user_manger('Tom', age = 22 , hobby = "Read" , job = "IT") # 传参时，关键字参数可以位置改变
user_manger('Lilei', 23 , 'IT' , 'Sing') # 不传关键字时，必须一一对应

思考下列两种方式是否可以？

user_manger('Lucy', age = 21 , 'IT' , 'Read')
user_manger('Lucy', 22 , 'IT' , age = 21)

user_manger('Lucy', age = 21 , 'IT' , 'Read')
# 报错将如下：
	user_manger('Lucy', age = 21 , 'IT' , 'Read')
                                  ^
SyntaxError: positional argument follows keyword argument
    
user_manger('Lucy', 22 , 'IT' , age = 21)
# 报错将如下：
	user_manger('Lucy', 22 , 'IT' , age = 21)
TypeError: user_manger() got multiple values for argument 'age'

关键参数必须放在位置参数(以位置顺序确定对应关系的参致)之后。

4.不定参数

Python的不定参数，主要指 *args 和 **kwargs 这两个魔法变量。那么它们到底是什么？

起始并不是必须写成 *args 和 **kwargs。只有变量前面的 * 才是必须的。也可以写成 **var **vars。而写成 *args 和 **kwargs 只是一个通俗的命名约定。

*args 和 **kwargs 主要用于函数定义。我们可以将不定义的参数传递给一个函数。

这里的不定的意思是：预先并不知道，函数使用者会传递多少个参数给你，所以在这个场景下使用这两个关键字。

• *args的用法

*args 是用来发送一个非键值对的任意数量的可变数量的参数列表给一个函数。

下面我们举例来帮大家理解：

def uncertain_para(para, *args):
    print("普通参数:", para)
    print("不定参数:", args)
    print(type(args))
    for arg in args:
        print('注意输出不定参数:', arg)
uncertain_para(1, 2, 3, 4, 5)    

运行后输出：

普通参数：1
不定参数：(2， 3， 4， 5)
<class 'tuple'>
逐一输出不定参数：2
逐一输出不定参数：3
逐一输出不定参数：4
逐一输出不定参数：5

我们可以看出，在这个例子中，para接受了传递的第一个参数，而args则是由所有其他位置参数组成的元组。

**kwargs

**kwargs 允许我们讲不定长度的键值对，作为参数传递给一个函数。

当我们想要在一个函数里处理一个带名字的参数时，就可以使用 **kwargs

比如：

def uncertain_para_key(**kwargs):
    print(type(kwargs))
    print(kwargs)

uncertain_para_key(a = 3, b = 4, c = 5)

运行后输出：

<class 'dict'>
{'a': 3, 'b': 4, c: 5}

*args 和 **kwargs 的使用

def test_args_kwargs(para1, para2, para3):
    print("para1:", para1)
    print("para2:", para2)
    print("para3:", para3)
    
args = ("abc", 6, 9)
print(test_args_kwargs(*args))
kwargs = {"para1":3, "para2":"xyz", "para3": [1, 2, 3]}
print(test_args_kwargs(**kwargs))

运行后输出：

para1: abc
para2: 6
para3: 9
None
para1: 3
para2: xyz
para3: [1, 2, 3]
None

注意这里传递键值参数时，需满足参数数量一致，否则会报错。

标准参数与 *args、 **kwargs在使用时的顺序

那么如果你想在函数里同时使用所有的这三种参数，顺序是这样的：

func(fargs, *args, **kwargs)

举例如下：

def test_args_kwargs(para1, *para2, **para3):
    print("para1:", para1)
    print("para2:", para2)
    print("para3:", para3)
    
print(test_args_kwargs(1, 2, 3, 4, a = 5, b = 6, c = 7))

输出结果为：

para1: 1
para2: (2, 3, 4)
para3: {'a': 5, 'b': 6, 'c': 7}
None