pyhon入门

视频

一，背景介绍

1.Python创始人：
吉多.范罗苏姆
2.编译器两种翻译方式：
编译，解释

3.Python的目标：

• 一门简单直观的语言并与主要竞争者一样强大。
• 开源，以便任何人都可以为它做贡献
• 代码像纯英语那样容易理解
• 适用于短期开发的日常任务

4.Python特点：

• Python是完全面向对象的语言
• Python拥有一个强大的标准库
• Python提供了大量的第三方模块

面向对象的思维方式：
面向对象是一种思维方式，也是一门程序设计技术
要解决一个问题前，首先考虑由谁来做，这么做事情是谁的职责
对象就是“谁”。
要解决复杂的问题，就可以找多个不同的对象，各司其职，共同实现

二，编译&运行

1.示例：

注意：

• 每行代码负责完成一个动作
• Python是一个格式非常严格的程序设计语言
• 目前而言，大家记住每行代码前面不要增加空格

Python 2.x 默认不支持中文。
Python 2.x 的解释器名称是Python。
Python 3.x 的解释器名称是Python3。

2.交互式运行Python程序
在Python 的Shell中直接输入Python的代码，会立即看到程序执行结果。
适合于学习/验证Python小的语法或者局部代码。

退出方式：
(1) >>> exit()
(2)Ctrl+“d”

4.IPython
是一个Python的交互式Shell,比默认的python shell好用。

• 支持自动补全
• 自动缩进
• 支持bash shell 命令
• 内置了许多很有用的功能和函数

Python 2.x 使用的解释器是ipython
Python 3.x 使用的解释器是ipython3

退出：
（1）exit
（2）Ctrl+“d”

三，Python的IDE(集成开发环境)—PyCharm

PyCharm的官方网站地址是：https://www.jetbrains.com/pycharm/
注意：要将压缩后的目录移动到/opt目录下，以便所有用户使用。

PyCharm的调试工具：

• F8 StepOver 会把函数调用看作是一行代码直接执行。
• F7 StepInto 会进入函数内部。

1. Python的使用

程序的作用：程序就是用来处理数据的。

Python的使用：在Python中，定义变量时是不需要指定变量的类型的。
在运行的时候，Python解释器会根据赋值语句等号右侧的数据自动推导出变量中保存数据的准确类型。

2.注释

格式：
单行注释“#”+“空格”+“注释内容”（上方）
代码和注释之间至少有两个空格（同行）
连续三个引号（多行）
代码规范：
Pychon官方提供有一系列PEP文档，其中8篇文档专门针对Python的代码格式做出了建议，也就是PEP8。

• 文档地址：https://www.python.org/dev/peps/pep-0008
• 谷歌有对应的中文文档：http://zh-google-styleguide.readthedocs.io/en/latest/google-python-styleguide/python_style_rules/

Tab键，多选缩进。
Tab键+shift键，减少缩进。

函数的注释最好放在函数内部，函数名下方用三个连续的引号（Ctrl + q 可查看）。
函数定义的上方，应该和其他代码（包括注释）保留两个空行。

3.标识符与关键字

标识符：

标识符也称变量名，函数名，标识符可以由字母，下划线和数字组成。

• 不能以数字开头
• 不能与关键字重名

关键字：
在Python内部已经使用的标识符查看Python中的关键字。

import keyword
print(keyword.kwlist)

• import 关键字可以导入一个 “工具包”
• 在Python中不同的工具包，提供由不同的工具

注意：

• Python中标识符是区分大小写的。
• 在定义变量时，为了保证代码格式，= 的左右应该各保留一个定格。
• 在 Python 中，如果变量名需要由两个或多个单词组成时，可以按照以下方式命名：
  单个单词都使用小写字母。
  单词与单词之间使用_下划线连接。
  例：first_name,qq_number…

关键字，函数和方法
关键字后面不需要使用括号。
函数名(参数)
对象.方向名(参数)

4.算法运算符

//	取整除	返回除法的整数部分，9//2输出结果是4
%	取余数	返回除法都余数，9%2=1
**	幂	又称次方，乘方，2**3=8

另外：
python3 把 long 和 int 都整合成了 int ；
Python2.x 中判断不等于，还可以使用 <> 运算符；

例：

"-" * 10

输出结果：

----------

5.逻辑运算符

与and/ 或or/ 非not 三种。

条件1 and 条件2
条件1 or 条件2
not 条件

6.字符串的转义字符

转义字符	描述
\	反斜杠符号
’	单引号
"	双引号
\n	换行
\t	横向制表符
\r	回车

7.函数的使用

序号	函数	说明
1	print(x)	将x输出到控制台
2	type(x)	查看x的变量类型

• 向控制台输出内容结束之后，不会换行

print("*", end="")

• 单纯的换行

print("")

• 在 ipthon 常使用 type(xxx) 来查看 xxx 的类型。

input("请输入银行密码")

在ipython如果代码有返回结果却没有变量接收，ipython就会有一个Out告诉我们输入的代码结果是什么，如果有变量，则不会有提示。
另外，用户的任何内容ipython都认为是一个字符串格式：

字符串变量 : input ("提示信息")

4.类型转换函数

函数	说明
int(x)	将x转换为一个整数
float(x)	将x转换成一个浮点数

8.变量的格式化输出

格式化字符	含义
%s	字符串
%d	有符号十进制整数，%06d时表示输出的整数显示位数，不足的地方使用0补全
%f	浮点数，%.2f表示小数点后只显示两位
%%	输出%

语法格式：

print("格式化字符串" % 变量1)
print("格式化字符串" % (变量1,变量2 ...))

例：

print("数据比例是 %.2f%% " % (scale*100))

9.三大流程介绍

顺序，分支，循环

10.随机数的处理

• 在Python中，要使用随机数，首先需要导入随机数的模块—“工具包”。
  import random
• 导入模块后，可以直接在模块前面敲一个"." , 然后按Tab键，会提示该模块中包含的所有函数。
• random.randint(a,b) ，返回[a,b]之间的整数，包括 a 和 b 。

#注意：在导入工具包的时候，应该将导入的语句放在文件的顶部。因为，这样可以方便下方的代码，在任何需要的时候，使用工具包中的工具。

11.if 语句判断

格式：

if 要判断的条件：
    条件成立时，要做的事情。
else:
    条件不成立时，要做的事情。

注意：
代码的缩进为一个tab键，或者4个空格——建议使用空格。

• 在 python 开发时，Tab和空格不要混用。

if 语言进阶：

if 条件1：
    条件1满足执行的代码。
elif 条件2：
    条件2满足执行的代码。
else:
    以上条件都不满足时执行的代码。

增加换行调整条件判断代码格式：

if(()
        or()
        or())  # 8个空格

12.while 语句基本语法

初始条件设置—通常是重复执行的计数器。

while 条件 (判断 计数器 是否达到 目标次数):
    条件满足时，做的事1
    条件满足时，做的事2
    ......
    处理条件（计数器+1）

13.函数

• 定义函数—封装独立的功能。
• 调用函数—享受封装的成果。

定义函数：

def 文件名():
    函数封装的代码
    ......

其他文件引入文件：

import 文件名
文件名.函数名()

#注意：定义好函数之后，表示这个函数封装了一段代码而已，如果不主动调用函数，函数是不会主动执行的。
在本文件中，通过函数名() 即可完成对函数的调用。

函数参数的使用：

def sum_2_num(num1,num2):  #形参
    result = num1 + num2
    print("%d + %d = %d " % (num1,num2,result))

sum_2_num(50,20)  #实参

def print_line(char,times):
    print(char * times)

print_line("-",40)

使用模块中的函数
模块是Python程序架构的一个核心概念。

• 模块就好比是工具包，要想使用这个工具包里的工具，就需要导入import这个模块。
• 每一个以扩展名py结局的python源代码文件都是一个模块。
• 在模块里定义的全局变量，函数都是模块能够提供给外界直接使用的工具。
• 模块名也是一个标识符。

14.Python中数据类型

Python中数据类型可以分成数字型和非数字型

• 数字型
• 整形
• 浮点型
• 布尔型
   真------非零即真
   假
• 复数型
   主要用于科学计算，例如：平面场问题，波动问题，电感电容等问题…
• 非数字型
   字符串
   列表
   元组
   字典

01 列表

name_list=["zhangsan","lisi","wangwu"]

name_list[0]

输入 name_list. 按下TAB键，ipython会提示列表能够使用的方法。

序号	分类	关键字/函数/方法	说明
1	增加	列表.insert(索引，数据)	在指定位置插入数据
		列表.append(数据)	在末尾追加数据
		列表.extend(列表2)	将列表2的数据追加到列表
2	修改	列表[索引]=数据	修改指定索引的数据
3	删除	del 列表[索引]	删除指定随意的数据
		列表.remove[数据]	删除第一个出现的指定数据
		列表.pop	删除末尾数据
		列表.pop(索引)	删除指定索引数据
		列表.clear	清除列表
4	统计	len(列表)	列表长度
		列表.count(数据)	数据在列表中出现的次数
5	排序	列表.sort()	升序排序
		列表.sort(reverse=True)	降序排序
		列表.reverse	逆转，反转

name_list = ["zhangsan", "lisi", "wangwu"]
# 1.取值
print(name_list[2])
#  使用index方法需要注意，如果传递的数据不在列表中，程序会报错
print(name_list.index("lisi"))
#  2.修改
#  列表指定的索引超出范围，程序会报错
name_list[1]="李四"
#  3.增加
name_list.append("王小二")
name_list.insert(1, "王小美")

temp_list = ["赵", "钱"]
name_list.extend(temp_list)
#  4.删除
#  在日常开发中，要从列表删除数据，建议使用列表提供的方法
name_list.remove("wangwu")  # 删除第一个wangwu，如果没有，则报错
name_list.pop()  # 默认删除最后一个元素
name_list.pop(3)
name_list.clear()

# del 关键字本质上是用来将一个变量从内存中删除
del name_list[1]
print(name_list)  # 错误，如果使用 del 关键字将变量从内存中删除，后续的代码就不能再使用这个变量了
#  5.统计
list_len = len(name_list)  # 统计元素的总数
#  统计列表中某一个数据出现的次数
count = name_list("lisi")
#  6.排序
name_list.sort()
name_list.sort(reverse=True)  # 降序
name_list.reverse()  # 反转（逆序）

Python的列表中可以存储不同类型的数据。

迭代 iteration 遍历

for name in name_list:
    print("我的名字叫 %s" % name)

02 元组

Tuple（元组）与列表类似，不同之处在于元组的元素不能修改。
使用()定义，经常保存不同类型的数据。

info_tuple = ("zhangsan" , 18 , 1.75)

for my_info in info_tuple:
    # 使用格式字符串拼接 my_info 这个变量不方便！因为元组中保存数据类型常不同。
    print (my_info)

定义单元素元组：

single_tuple = (5,)  # 如果没有","，就是int类型

格式化字符串后面的 “()” 本质上就是元组。

info_tuple=("小明",21,1.85)
print(" %s 年龄是 %d 身高是 %.2f " % info_tuple)

使用格式化字符串可以用元组拼接一个新的字符串。

info_str = " %s 年龄是 %d 身高是 %.2f " % info_tuple
print(info_str)

03 元组和列表之间的转化

• 使用list函数可以把元组转换成列表
  list(元组)
• 使用tuple函数可以把列表转换成元组
  tuple(列表)

04 字典

dictionary(字典)是除列表以外Python之中最灵活的数据类型。
字典同样可以用来存储多个数据。
和列表的区别：

• 列表是有序的对象集合
• 字典是无序的对象集合
  字典用 {} 定义
  字典使用键值对存储数据，键值对之间使用 “，” 分隔。
• 键key是索引
• 值value是数据
• 键和值之间使用 “：” 分隔
• 键必须是唯一的
• 值可以取任何数据类型，但键只能使用字符串，数字或元组。

# 字典是一个无序的数据集合，使用print函数输出字典时，通常输出的顺序和定义的顺序是不一样的。
xiaoming = {"name": "小明"}
# 1.取值
print(xiaoming["name"])
# 2.增加/修改
xiaoming["age"] = 18
# 如果key存在，会修改已经存在的键值对
xiaoming["name"] = "小小明"
# 3.删除
xiaoming.pop("name")
print(xiaoming)
# 4.统计键值对数量
print(len(xiaoming))
# 5.合并字典
# 如果被合并的字典中包含已经存在的键值对，会覆盖原有的键值对
temp_dict = {"height": 1.75,
             "age": 20}
xiaoming.update(temp_dict)
# 6.清空字典
xiaoming.clear()

迭代遍历字典

for k in xiaoming:
    print("%s - %s" % (k,xiaoming[k]))

应用：
将多个字典放在一个列表中，再进行遍历，在循环内部针对每一个字典进行相同处理。

card_list = [
    {"name": "zhangsan",
    "qq": "12345"},
     {"name": "lisi",
    "qq": "54321"}
]
for card_info in card_list:
    print(card_info)

05 字符串

字符串：
在Python中可以使用一对双引号或者一对单引号定义一个字符串。

str = '我的名字是"大西瓜"'

for char in str:
    print(char)

hello_str = "hello hello"
# 1.统计字符串长度
print(len(hello_str))
# 2.统计某一个子串出现的次数.
print(hello_str.count("abc"))
# 3.某一个字串出现的位置
print(hello_str.intex("llo"))

1）判断类型

方法	说明
string.isspace()	如果string中只包含空格，则返回True ,制表符也属于空白字符，例：\r,\t,\n
string.isalnum()	如果string至少有一个字符并且所有字符都是字母或数字则返回True
string.isalpha()	如果string至少有一个字符并且所有字符都是字母则返回True
string.isdecimal()	如果string只包含数字则返回True，全角数字 ，不能判断小数
string.isdegit()	如果string只包含数字则返回True，全角数字，(1)，unicode字符串：\u0062，不能判断小数
string.isnumeric	如果string只包含数字则返回True，全角数字，(1)，汉字数字：一千零一，不能判断小数
string.istitle()	如果string是标题化的，（每个单词的首字母大小）则返回True。
string.islower()	如果string中包含至少一个区分大小写的字体，并且所有这些区分大小写的字符都是小写，则True。
string.isupper()	如果string中包含至少一个区分大小写的字体，并且所有这些区分大小写的字符都是大写，则True。

2）查找和替换

方法	说明
string.startswith(str)	检查字符串是否以str开头，是则返回True。
string.endswith(str)	检查字符串是否以str结束，是则返回True。
string.find(str,start=0,end=len(string) )	检测str是否包含在string中，如果start和end指定范围，则检查是否包含在指定范围，如果是则返回开始的索引，否则返回-1。
string.rfind(str,start=0,end=len(string))	类似于find()函数，不过是从右向左
string.index(str,start=0,end=len(string))	跟find()方法类似，只不过如果str不在string则会报错。
string.rindex(str,start=0,end=len(string))	类似于index()，不过是从右向左。
string.replace(old_str,new_str,num=string.count(old_str))	把string中old_str替换成new_str，如果num指定，则替换不超过num次

hello_str = "hello world"
# 1.查找指定字符串
print(hello_str.find("llo"))
# index如果指定字符串不存在，会报错
# find如果指定的字符串不存在，会返回-1
# 2.替换字符串
hello_str.replace("world","python")
# replace方法执行完成之后，会返回一个新的字符串
# 注意：不会修改原有字符串的内容

3）大小写转换

方法	说明
string.capitalize()	把字符串的第一个字符大写
string.title()	把字符串的每个单词首字母大写
string.lower()	转换string中所有大写字符为小写
string.upper()	转化string中所有小写字符为大写
string.swapcase()	翻转string中的大小写

4）文本对齐

文本	说明
string.ljust(width)	返回一个原字符串左对齐，并使用空格填写至长度width的新字符串。
string.rjust(width)	返回一个原字符串右对齐，并使用空格填写至长度width的新字符串。
string.center(width)	返回一个原字符串居中，并使用空格填写至长度width的新字符串。

5）去除空白字符

文本	说明
string.lstrip(width)	截掉string左边（开始）的空白字符
string.rstrip(width)	截掉string右边（末尾）的空白字符
string.strip(width)	截掉string左右两边的空白字符

poem = ["\t\n登鹳雀楼","王之涣\t\n"]
for poem_str in poem:
    print("|%s|" % poem_str.strip().center(10,"中文空格"))

6）拆分和连接

方法	说明
string.partition(str)	把字符串string分成一个3元素的元组（str前面，str，str后面）
string.rpartition(str)	类似于partition函数，不过是从右边开始查找
string.split(str=“”,num)	以str为分隔符切片string，如果默认包含 ‘\r’, ‘\t’, ‘\n’ 和空格。
string.splitlines()	按照行 ‘\r’, ‘\n’, ‘\r\n’ 分隔，返回一个包含各行作为元素的列表
string.join(seq)	以string作为分隔符，将seq中所有的元素(的字符串表示)合并为一个新的字符串

poem_str = "登鹳雀楼\t王之涣\t\n白日依山尽\t"
# 1.拆分字符串
poem_list = poem_str.split()
print(poem_list)
# 2.合并字符串
result = " ".join(poem.list)
print(result)

05 切片

支持的数据类型：字符串，列表，元组。

字符串 [开始索引: 结束索引: 步长]

指定的区域是左闭右开的。
不指定结束索引，则默认到末尾；不指定开始序列，则默认在序列开头。

In:(0,1,2,3,4)[1:3]
Out:(1,2)

num_str = "0123456789"
In[1]:num_str[2:] 
Out[1]:'23456789'
# 从开始位置，每隔一个取一个
In[2]:num_str[::2]
Out[2]:'02468'
# 从2到末尾-1的字符串
In[3]:num_str[2:-1]
Out[3]:'2345678'
# 字符串的逆序
In[4]:num_str[-1::-1]
Out[4]:'9876543210'
# 或者
In[5]:num_str[::-1]
Out[5]:'9876543210'

06 Python内置函数

函数	描述	备注
len(item)	计算容器中元素个数
del(item)	删除变量	del有两种方式
max(item)	返回容器中元素最大值	如果是字典，只针对key比较
min(item)	返回容器中元素的最小值	如果是字典，只针对key比较
cmp(item1,item2)	比较两个值	Python 3.x 取消

In[6]:t_str = "fhkdjsizcvbxnqskywfq"
In[7]:max(t_str)
Out[7]:'z'

In[8]:t_list = [5,2,4,8,1]
In[9]:min(t_list)
Out[9]:1

# 对于字典只会对键统计，而不会对值统计
In[10]:t_dict = {"a":"z","b":"y","c":"x"}
In[11]:max(t_dict)
Out[11]:'c'

07 运算符

运算符	Python表达式	结果	描述	支持的数据类型
+	[1,2]+[3,4]	[1,2,3,4]	合并	字符串，列表，元组
*	[“Hi”]*4	[‘Hi!’,‘Hi!’,‘Hi!’,‘Hi!’,‘Hi!’]	重复	字符串，列表，元组
in	3 in (1,2,3)	True	元素是否存在	字符串，列表，元组，字典
not in	4 not in (1,2,3)	True	元素是否存在	字符串，列表，元组，字典
> >= == < <=	(1,2,3)<(2,2,3)	True	元素比较	字符串，列表，元组

"+"是生成一个新的列表，而extend,append是直接在原来的上面修改。
而extend与append区别在于，append会将列表函数作为一个元素追加到列表变量中。

In[12]:t_list.append([8,9])
In[13]:t_list
Out[13]:[1,2,3,4,[8,9]]

注意：

• in在对字典操作时，判断的是字典的键
• in和not in被称为成员运算符

15.完整的for循环语法：

for 变量 in 集合:
    循环体代码
else:
    没有通过break退出循环1，循环结束后，会执行的代码

如果循环体内部使用break退出了循环，else下方的代码就不会被执行。

应用场景：在迭代遍历嵌套的数据类型做数据搜索时

16.LINUX上的Shebang符号（#！）

用法：在主程序的第一行增加Shebang标记。
增加权限的方法：

chmod _x  cards_main.py

17.可变类型与不可变类型

# 查询num的内存地址
id(num)

不可变类型：
 数字类型 int bool float complex long(2,x)
 字符串 str
 元组 tuple
可变类型（不能作为键值对的key）：
 列表 list
 字典 dict

哈希（hash）
Python中内置有一个名字叫做hash( )的函数。

• 接收一个不可变类型的数据作为参数
• 返回结果是一个整数

提取数字特征码：

• 在Python中设置字典的键值对时，会首先对key进行hash以决定如何在内存中保存字典的数据，以方便后续对字典的操作：增，删，查，改。
• 键值对key必须是不可变类型数据
• 键值对的value可以是任意类型的数据

18.局部变量与全局变量

• 局部变量是在函数内部定义的变量，只能在函数内部使用。
• 全局变量是在函数外部定义的变量（没有定义在某一个函数内），所有函数内部都可以使用这个变量。

局部变量的生命周期

• 所谓生命周期就是变量从被创建到被系统回收的过程。
• 局部变量在函数执行时才会被创建。
• 函数执行结束后，局部变量被系统回收。
• 局部变量在生命周期内，可以用来存储函数内部临时使用的数据。

在Python中，是不允许直接修改全局变量的。
如果使用赋值语句，会在函数内部定义一个局部变量。

如果在函数内部需要修改全局变量的值，使用global声明一下变量即可。

# global关键字会告诉解释器后面的变量是一个全局变量。
# 再使用赋值语句时，就不会创建局部变量
global num
num = 99

注意：
在开发时，应该把模块中的所有全局变量定义在所有函数上方，就可以保证所有的函数都能够正常的访问到每一个全局变量了。
代码结构示意图：

命名：
如果局部变量的名字和全局变量的名字相同
pycharm会在局部变量下方显示一个灰色的虚线。
为避免局部变量和全局变量出现混淆，在定义全局变量时，有些公司会有一些开发要求：
全局变量名前应该增加 g_ 或者 gl_ 的前缀。

19.函数和返回值

（1）如果函数内部处理的数字不确定，就可以将外界的数据以参数传到函数内部。
（2）如果希望一个函数执行完成后，向外界报告执行结果，就可以增加函数的返回值。

函数返回多个值：

def measure():
    temp = 39
    wetness = 50
    # 如果函数返回的类型是元组，小括号可以省略。
    return (temp,wetness)
# 元组
result = measure()
print(result)

如果函数返回的类型是元组，同时希望单独的处理元组中的元素。
可以使用多个变量，一次接收函数的返回结果

# 注意：使用多个变量接收结果时，变量的个数应该和元组中元素的个数保持一致。
gl_temp,gl_wetness = measure()
print(gl_temp)
print(gl_wetness)

交换 a,b 的值：

# !.
a = a+b
b = a-b
a = a-b
# 2.
# a,b = (b,a)
a,b = b,a

20.赋值

只要针对参事使用赋值语句，会在函数内部修改局部变量的引用，不会影响到外部变量的引用。

• 如果传递的参数是可变类型，在函数内部使用方法修改了数据的内容，同样会影响到外部的数据。
• 列表变量使用 += 不会做相加再赋值的操作，本质上是调用列表的 extend 方法。

num_list += num_list
# 然而以下不会有影响
num_list = num_list + num_list

21.缺省参数

定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就叫做缺省函数。
调用函数时，如果没有传入缺省函数的值，则在函数内部定义函数时指定的参数默认值。
函数的缺省函数，将常见的值设置为参数的缺省值，从而简化函数的调用。
例：

gl_list = [6,3,9]
# 默认按照升序排序
# gl_list.sort()
# 如果需要降序排序，需要执行 reverse 参数
gl_list.sort(reverse=True)
    print(gl_list)

指定函数缺省函数的默认值：

def print_info(name,gender=True):
    gender_text = "男生"
    if not gender:
        gender_text = "女生"
    print("%s 是 %s" % (name,gender_text))

提示：
在提示缺省函数的默认值时，应该使用最常见的值作为默认值。
如果一个参数的值不能确定，则不应该设置默认值，具体的数值在调用函数时，向外界传递！

注意事项：
必须保证带有默认值的缺省函数，在参数列表末尾。
在调用函数时，如果有多个缺省函数，需要指定参数名，这样解释器才能够知道参数的对应关系。

def print_info (name,gender = True)

22.多值函数

有时可能需要一个函数能处理的参数个数是不确定的，这个时候，就可以使用多值函数。
python 中有两种多值函数

• 参数名前增加一个 * 可以接收元组。
• 参数名前增加两个 * 可以接收字典。

*args --- 存放元组
**kwargs --- 存放字典

def demo(num,*nums,**person):
    print(num)
    print(nums)
    print(person)
demo(1,2,3,4,5,name="小米",age=18)

def sum_numbers(*args):
    num=0
    print(args)
    for n in args:
        num+=n
    return num
result = sum_numbers(1,2,3,4,5)
print(result)
# result = sum_numbers(1,2,3,4,5)

23.元组和字典的拆包

在元组变量前，增加一个 *
在字典变量前，增加两个 *

def demo(*args,**kwargs):
    pass
gl_nums = (1,2,3)
gl_dict = {"name":"小明","age":18}
demo(*gl_nums,**gl_dict)

23.递归

一个函数自己调用自己。
例：递归实现数字累加。

def sum_numbers(num):
    if num==1
        return 1
    temp = sum_numbers(num-1)
    return num+temp

补充：

1.Map:

Map函数：将一个函数映射到一个输出列表的所有元素上。
列表中所有元素一个个地传递给一个函数，并收集输出：

map(function_to_qpply,list_of_inputs)

例一：

def f(x):
    return x*x
list1 = [1,2,3,4,5]
r =  map(f,list1)
print(list(r))

输出：

[1,4,9,16,25]

例2：

def f1(x,y):
    return x+y
list1 = [1,2,3,4,5]
list2 = [11,12,13,14,15]
m1 = map(f1,list1,list2)
print(list(m1))

输出：

[12,14,16,18,20]

2.seed()

语法：

import random
random.seed(x)

我们调用random.random()生成随机数时，每一次生成的数都是随机的，但是，当我们预先使用random.seed(x)设定好种子之后，其中的x可以是任意数字，如10，这个时候，先调用它的情况下，使用random（）生成的随机数将会是同一个

3.print

三种输出方式：

• % 格式

print('整数部分是%s,小数部分是%s' % (zs,zx))

• format格式

print('周长={:0.2f}\n面积是={:0.2f}'.format(zc,area))

• f 格式

print(f'周长={zc:0.2f}\n面积={area:0.2f}')

4.upper()

str.upper()
返回小写字母转为大写字母的字符串

5.enumerate

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))       # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
>>> tuple(enumerate(seasons, start=1))
((1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter'))

for循环
例1：

for i in range(len(numbers)-1):
    s += l1[i] * int(numbers[i])
## 对比
for index, number in enumerate(numbers[:-1]):
    s += l1[index] * int(number)

例2：

seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
     print (i, element)
 

6.lambda

lambda表达式通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用。
将字典用sort升序排序

dict1 = sorted(dict1.items(),key=lamda x:x[0],reverse=False)

例：
将一个字典,即dict1={0:0.28,1:0.25,2:0.45}按照值的大小进行排序。
目标：dict1={0:25,1:0.28,2:0.45}

dict1={0:0.28,1:0.25,2:0.45}
dict1 = sorted(dict1.items(),key=lambda kv:kv[1])
# tuple类型
dict1 = dict(dict1)
dict2 = []
for value in dict1.values():
    dict2.append(value)
for i in range(3):
    dict1[i]=dict2[i]
dict1 = sorted(dict1.items(),key=lambda kv:kv[1])
dict1 = dict(dict1)
print(dict1)