python基础(未完)

前言：近几日在学习sql注入时发现需要使用python编写脚本，故来学习一下python

参考：菜鸟教程

python从入门到实践 第二版

1.1 python的编码

python3源码文件以utf-8编码，所有字符串都是unicode，也可以使用别的编码方式，比如

# -*- codeing: cp-1252 -*-

1.2 标识符与保留字

python的标识符和保留字

>>> import keyword
>>> 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']

使用keyword模块可以快速输出所有的关键字。

1.3 注释

python中单行注释是以#开头的

python中的多行注释可以是'''

或者是"""

具体的使用如下

'''print("dasdasd")
'''

或者

"""
print(111)
"""

1.4 行进与缩进

python 并不使用{}来表明作用域，而是使用缩进来表示。

比如

if (1):
    print(1)

这里顺便就把python的if一并说明一下

python中的条件并不需要用括号括起来，但括起来也可也，为了保持一贯的习惯，我就括起来写

了，但实际上也可以像下面这样

if 1:
    print(1)

注意：python是解释型编程语言，并不需要分号，无论是分支语句还是循环语句，都需要在条件

完加上分号

好了，我们回到正题，Python的作用域使用缩进来进行区分

所以一下这种情况自然无法运行

if True:
    print ("Answer")
    print ("True")
else:
    print ("Answer")
  print ("False")    # 缩进不一致，会导致运行错误

1.5 python的多行语句

由于python没有分号，故是以行为判读结尾的依据，故不能像别的语言那样一行压缩许多代码。

但是如何将代码写在多行内呢？

第一种方法，使用()

具体的使用如下

a = (1 +
     2)
print(a)

当然也可以使用[] {}等实现，需要注意的是，如果在一些不需要使用到[]

或者{}地方使用这两个括号进行拼接，会导致输出也会显示这两个括号。

但在数组等地需要用到该括号的地方则没事。

1.6 python 的输出

python 使用print来进行输出

print('1')

print 的输出默认是要进行换行的，如果不需要换行，只需要在变量末尾加上end=“ ”

比如

print(1, end=" ")
print(1)

使用该操作可以在输出完不进行换行。

1.7 基本数据类型

python不同于c++和java，变量必须要声明，python的变量无需声明，但每个变量使用前必须进

行赋值，赋值后变量才会被创建

而且python中的变量并不需要像 php中需要用$来表明其是个变量，具体的使用如下

a=1
print(a)

这就是一个简单的变量赋值和变量输出。

python中也允许同时为多个变量赋值，例如

a=b=c=1

在以上的例子中同时给abc赋值

也可也同时为不同的变量赋不同的值，例如

a,b,c=1,2,3

分别给a,b,c赋值1,2,3

1.8 python的变量引用机制

这是python区别于其他编程语言的独特机制，但由于暂时用不到，就暂时搁置下

1.9 数据类型

python3中有一下几种数据类型：

Number String bool List(列表) Set(集合) Tuple(元组) Dictiondary(字典)

1.9.1 Number

number中分为int float bool complex(复数)

几种，其中需要注意的就是复数，这在其他编程语言中是很少见的。

使用type()可以用来查询呢变量所指的对象类型。

具体使用如下

a=1
print(type(a))

此外还可以使用

instance来进行判断，具体操作为

a = 1
print(isinstance(a, int))

返回结果是true，该函数用于检测变量或字面量是否为后面的数据类型。

当然这两个也存在不少区别，最大的区别为 type()不会认为字类是一种父类类型,而isinstance会

认为子类是一种父类类型，具体的等学到类再具体探讨。

注意，我们创建一个变量的过程的过程就是将对应的数据类型作为类实例化的过程，在python3中bool

是int 的子类，而且True可以和数字相加，True=1，False=0.

我们需要注意的是，在python3中True和False 对大小写有严格限制，也就是我们不能写成false或者

true.

print(False+1)

在这个语句中，flase被当作0处理了，所以输出结果为1

由于python的变量引用机制，使用del语句可以删除对对象的引用

比如

a=1
del a

在python中的数值运算和其他语言稍有不同

处除了经典的+ - * / %

还有// 单除号返回的是一个字符串，双除号返回的是一个整数

返回的这个整数类似于强制类型转换后浮点数到整数的变化，将小数部分直接省略掉。

还有** 这是乘方运算，不像c++中单独以函数的形式，而是直接定义了一种运算形式。

在python中，当你书写很大数字时，可以用下划线进行分割，输出的时候不会打印下划线实际

参与数字运算的同时也不会考虑进下划线

比如

a = 1_1
b = a+1
print(b)

2.0 字符串

首先，我们要明白，python中单引号和双引号没有任何区别，但存在双引号，可以容纳多行内

容，比如

a = '''   23232
    111'''
print(a)

输出结果为

23232
111

python中的转义符还是为\，也就是说想要在单引号中打出单引号，或者在双引号中打出双引号就要

使用该转义符号，例如

print('\'')

输出为‘

对于字符串对象，我们可以使用title获得其首字母开头大写的形式具体的使用如下

str='ab ac'
print(str.title())

输出结果为Ab Ac

转化为小写的方法为str.upper()

转换为大写的方法为str.lower()

注意，这两个方法只是将转化后的结果返回回来了，并不会改变实际字符串值

python有个神奇的地方，那就是字符串不需要符号进行拼接，直接连接即可

比如

full_name = "23""1"
print(full_name)

输出结果为 231

如果想要在字符串内使用变量，可以使用f字符串，具体的使用如下

first_name = "ada"
last_name = "lovelace"
full_name = f"{last_name}"f"{first_name}"
print(full_name)

在花括号中放变量名，然后自动解析为变量的值，可以这样分开写，当然也可也合起来写，就

像这样

full_name = f"{last_name}{first_name}"

这样也是可行的

其实f字符的本质就是会让花括号内的内容进行解析，所以我们这样用也是可以的

first_name = "ada" 
last_name = "lovelace"
full_name = f"{first_name} {last_name}"
print(f"Hello, {full_name.title()}!")

注意，f字符串是python 3.6引入的，3.6前应该使用format()方法

经过这么多方法的学习，我们可以发现一个规律，字符串方法一般不会直接改变字符串的值，只

是将执行后的结果返回回来罢了，下面我们要学习的列表却并不是这样

2.1 制表符和换行符

使用\t来代之制表符，用\n 来代之换行符，直接在双引号内可以进行解析

print("11")

结果为：

11

如果加上制表符

print("\t11")

结果为

        11

发现区别了吧

换行符如下

print("11\n11")

这样就可以实现换行了

如果字符串两边有空白该怎么办呢？strip函数可以帮助我们解决这个问题

str.rstrip()可以返回去除最右侧空格的字符串

str.lstrip() 可以返回去除最左侧空格的字符串

str.strip()可返回去除了两侧空格的字符串

但需要注意的是，这几个方法只是将去除过空格的字符串返回，并不是直接更改字符串的值，

需要更改的话还得赋值一下

2.1 变量

python中的变量使用起来也较为方便

a=1
print(a)

这样就可以输出a的值了

在使用python需要遵守一些规则和指南，第一点：变量名只能包含字母数字和下划线，且不能

以数字打头

不要使用关键字和函数名作为变量名

2.0什么是列表

列表是由一系列按特定顺序排列的元素组成，你可以往里面放各种数据，感觉更像c++中的队

列，从下面的几个方法也能看出来，基本和队列没啥区别在python中用[]表示列表，并用逗号

分隔其中的元素。

a = ['a', 'aa', 'bbb']
print(a)

打印结果为

['a', 'aa', 'bbb']

2.1 访问列表元素

访问方式也和队列的访问差不多

a = ['a', 'aa', 'bbb']
print(a[0])

输出结果为0

2.2在列表末尾添加元素

使用列表对象的append方法给列表的末尾添加元素

具体用法如下

a = ['a', 'aa', 'bbb']
a.append(1)
print(a[3])

1被添加到了列表末尾，所以输出的结果为1

该方法为动态创建列表提供便利，我们完全可以先创建一个空列表，然后再在其中添加元素，这

种方式也最常见

a = []
a.append(1)
a.append(2)
print(a)

2.3 在列表中插入元素

使用insert方法可以在列表中插入元素，具体的使用为

list.insert(索引，值)

如果这个位置有元素，则会将原来从当前位置的元素，到队列的末尾向右移动一位，包括原位置

如果当前位置没有元素，即使你插入在了那里，也会自动接在末尾，比如一个队列中0,1位置有

元素 我在3位置插入一个元素，但因为3位置的前面没有元素，所以你插入的元素会自动到2号位

a = []
a.append(1)
a.append(2)
a.insert((2), 1)
print(a[2])

2.4 在列表中删除元素

使用del在列表中删除元素，具体的操作如下

a = []
a.append(1)
a.append(2)
del a[0]
print(a[0])

当删除列表中间的一个数据时，列表会自动向前补齐，所以输出的结果是

使用pop() 方法可以弹出列表中的最后一个元素，越学越觉得这和队列没区别，连几个方法都是

一样的

a = []
a.append(1)
a.append(2)
a.pop()
print(a[0])

由于将最后的元素弹出了，所以输出值为1

注意：pop方法是有返回值的，返回的值就是弹出的那个元素

当然也可以指定位置弹出

给pop方法传参就行了

a = []
a.append(1)
a.append(2)
# a.pop()
print(a.pop(0))

返回结果为 ['b', 'a']

如何根据值删除元素呢？这时候就要用到remove()方法了，但我们需要注意的是，remove()方

法没有返回值，而且删除的是从列表首部到列表尾部找到的第一个元素，也就是你如果删除一个

在列表中出现多次的值，那么使用一次remove()只会删除第一个值，如果需要全部删完则得多次

循环

具体使用如下：

a = []
a.append('a')
a.append('b')
a.append('a')
a.remove('a')
print(a)

输出结果为：['b', 'a']

2.5 给列表排序

这时候就要用到我们熟悉的sort函数了，sort排序规则为按字典序排序，需要注意的是使用sort

方法时，要保证列表内存储的数据类型相同，也就是sort方法无法给存储类型不同的列表排序

还有需要注意的是，在字典序中,数字的优先级高于字母，也就是数字会排在字母前。大小写不影

响字典序排序

具体的使用如下

a = []
a.append('a')
a.append('2')
a.append('b')
a.sort()
print(a)

输出结果为：['2', 'a', 'b']

如果你只是想输出一下排序的结果，却不想改变原序列顺序该怎么办呢?这时候就要使用sorted()

函数了，该函数的返回值就是排序过的列表。

a = []
a.append('a')
a.append('2')
a.append('b')
print(sorted(a))
print(a)

输出结果如下：['2', 'a', 'b']
['a', '2', 'b']

2.6 将列表转换为倒叙

使用reverse()方法可以逆转列表比如 1234 逆转为4321

这个更改是直接作用于列表本身的，并不会产生返回值，具体的使用如下

a = []
a.append('a')
a.append('2')
a.append('b')
print(a)
a.reverse()
print(a)

下面是输出结果

['a', '2', 'b']
['b', '2', 'a']

由于倒序是永久性的，想要恢复只需要再来一遍reverse即可

2.7 确定表的长度

通过len函数可以确定列表的长度

a = []
a.append('a')
a.append('2')
a.append('b')
print(len(a))

由于有三个元素，所以返回3

2.8 遍历整个列表

操作很简单

a = []
a.append('a')
a.append('2')
a.append('b')
for i in a:
    print(i)

由于在python中每个输出的末尾都会带个换行符，所以最终的输出为

a
2
b

在使用python中一定要注意，由于python不用花括号限定作用域，所以必须得严格进行缩进，

不能随意缩进，不能多缩进也不能少缩进

2.9 创建数值列表

首先来学习一下range()函数的使用

首先，它可以用来打印一系列数字，具体操作见如下

for i in range(0, 5):
    print(i)

它将输出0到4的数字，注意，负数也可也输出

还需要注意的是，该函数的输出区间为左闭右开，这就是不会输出5的原因

默认不加参数的情况下，一次自增一个数，我们传入的第三个参数可以觉定一次自增的数

比如：

for i in range(0, 5, 2):
    print(i)

输出结果为

0
2
4

因为一次自增2,所以输出结果为0,2,4

如果我们想把range()的结果转换为列表该怎么办呢？这时候就要用到list方法了，在python 2

中，range函数直接返回一个列表，在Python 3.x版本中，它返回一个可迭代对象，可以通过

list()函数将其转换为列表。

比如:

print(list(range(1, 4)))

返回结果为[1, 2, 3]

3.0 列表操作函数

有几个用来处理数字列表的函数

第一个是mix函数，返回数字列表中最大的数

具体的使用如下

a = []
a.append(1)
a.append(2)
a.append(5)
print(max(a))

返回的自然是5

与之相对的，还有min函数和sum函数，我们从函数名字应该就可以猜到这两个函数是干什么的

了

3.1 列表解析

如何快速生成一个特殊列表呢？用循环一个个的赋值？当然可以，就是有点慢，python 为了解

决这个问题，使用了列表解析，让你只需要编写一行代码就能生成列表，列表解析将for循环和创

建新的列表融为一体，具体的使用见下:

a = [i**2 for i in range(1, 5)]
print(a)

就这样构造了一个简单的乘方列表，输出如下

[1, 4, 9, 16]

需要注意的是，使用列表解析快速生成的列表的末尾没有冒

3.2 切片输出

如何我们只想输出列表的一部分，又应该怎么做呢?

这时候就要使用切片输出了

基本的语法为：列表名[左起点:右边起点]

需要注意的是，这个区间和range的区间一样，都是左闭右开的。

比如

a = [i**2 for i in range(1, 5)]
print(a)
print(a[0:3])

输出结果为[1, 4, 9, 16]
[1, 4, 9]

如果没有指定第一个索引，将从头开始输出

比如

a = [i**2 for i in range(1, 5)]
print(a)
print(a[:3])

输出结果和上相同

如果没有指定末尾的索引，将直接输出到列表末尾后停止

关于python的索引，上面所描述的是从正序索引，还有逆序索引，就是倒着来计数

比如：

a = [i**2 for i in range(1, 5)]
print(a)
print(a[:-2])

输出是从第一个元素倒数第二个元素，由于是左闭右开，所以输出

1 4

同理，我们也可也这样

a = [i**2 for i in range(1, 5)]
print(a)
print(a[-3:])

输出结果为：4，9，16

当然也可以传入第三个值，使得每次跳过几个数输出。

3.3 复制列表

如何复制一个列表呢？复制一个列表，当然不能直接把旧列表的值赋给新列表，我们首先要创建

一个切片，构建出列表的副本，然后将这个副本赋值给新的列表即可。

具体的使用如下：

a = [i**2 for i in range(1, 5)]
b = a[:]
print(a)
print(b)

不由的就会好奇，如果直接将旧列表的值赋给新列表会怎样呢?

根据python的变量存储机制，我们知道，每一个变量名其实是充当索引指向变量值实际存储的地

址，那我们直接将旧列表赋值给新列表，那么新列表指向的列表和旧列表指向的列表就完全相同

了，所以这并不能算是列表的复制。

a = [i**2 for i in range(1, 5)]
b = a
b.append(2)
print(a)

就比如这样，看似是对b的改变，实际也改变了a的值

3.4 什么是元组

在学习python的数据类型时我们曾提到过，python中存在可变的数据类型，也存在不可变的数

据类型，上文中的列表就是python中的可变数据类型，用于存储需要进行更改的变量，而元组是

不可变数据类型之一，可以把它理解成不可变的列表

元组和列表很像，列表定义时使用中括号进行标识，元组定义时使用圆括号进行标识，元组的读

取与列表相同，都是利用[]进行读取具体的使用如下

a = (1, 2, 3)
print(a[0])

输出结果为1，我们试着改变下元组的值，发现会报错，所以元组的值只能在定义时给出，无法

像列表一样在后续进行修改。类似于c++中的静态数组。

严格的来说，元组是用逗号标识的，即使定义的元组中只有一个元素，也需要使用逗号。比如

a = (1, )
print(a[0])

3.5 元组的输出

和列表的输出没什么区别

a = (1, 2, 3,)
for i in a:
    print(i)

3.6 if

python 中的if和其他语言基本没区别，就是把&&换成了and 把||换成了 or

比如：

if 1 > 2 or 2 > 1:
    print(1)

其次就是else if 变成了 elif

python中的if还有一种特殊的功能，直接检测值是否在数据结构中，在我介绍的这几种数据结构

中都可以使用，具体的使用如下

a=[]
a.append(1)
a.append(2)
if 1 in a:
    print(3)

有了in ，那当然就有 not in 用法和in是相同的，只不过是将在变为了不在

3.7 字典的建立

字典和上面的列表和元组的区别在于，字典的索引并不一定是数字，可以自己设定。

字典的使用如下

a={'a':1,'b':2}
print(a['a'])

使用花括号限定作用域，调用方式也和前二者相同

他属于可变数据类型，所以可以对其的值进行改变

a={'a':1,'b':2}
a['a']=2
print(a['a'])

直接输出字典可以查看字典内部的组成，例如

a={'a':1,'b':2}
a['a']=2
print(a)

输出结果为{'a': 2, 'b': 2}

如果我们一开始并不知道要设定几个元素呢？那么就先定义，再给值

比如：

a={}
a['a']=2
print(a)

像这样完全是可行的，我们创建了一个空字典用于存放值

当然是可以使用纯数字作为键名的。

3.8 删除键值对

对于字典中不需要的数据，我们使用del进行删除，具体操作如下

a={}
a['a']=2
a['b']='c'
del a['a']
print(a)

这样就实现的删除特定键值对的操作，输出结果为

{'b': 'c'}

但需要注意的是，这样操作时需要指定特定的键

3.9 get方法

使用get方法可以获得特定键名的值，如果该键不存在，可以返回预定设置的内容，具体的使用

如下

a={}
a[1]=2
a['b']='c'
print(a.get('a',"404"))

由于字典中没有键a,所以返回值为404,如果没有指定第二个参数且键不存在，python将返回

None。

4.0 字典的循环输出

如果单纯想要输出键，那和先前有些不同，注意，先前这样输出的是值，在字典中这样输出的是

键，这是最主要。

a={}
a[1]=2
a['b']='c'
a['a']=1
for i in a :
    print(i)

输出结果为

1
b
a

如果我们想要同时输出键和值，则可以这样输出

a={}
a[1]=2
a['b']='c'
a['a']=1
for i,j in a.items() :
    print(i,j)

输出结果为：

1 2
b c
a 1

items方法可以以元组的形式返回对应的键值对，前面的i j变量第一个代表键，第二个代表值，这

两个变量的名称可以随意设置

如果我们想便利所有的键，哪该怎么办呢？这时候应该使用key() 方法了。

具体的使用如下

a={}
a[1]=2
a['b']='c'
a['a']=1
for i in a.keys() :
    print(i)

这样便可以输出所有的键了，和我们最初介绍的输出键的输出相同

我们如何按特定顺序输出字典，第一种方法就是在循环的时候使用sorted对其进行排序，然后再

输出，这样操作是按照键的字典序进行输出的，并非是根据值的字典序进行输出，具体的使用如

下

a={}
a[5]=5
a[2]=3
for i in sorted(a):
    print(i)

2
5

如果我们想输出具体的值，就应该使用value() 方法，具体的使用如下

a={}
a[5]=5
a[2]=3
for i in a.values():
    print(i)

输出结果为：5
3

无论输出什么值，如果我们想要去重，该怎么办呢？这是就要使用set函数了

a={}
a[5]=5
a[2]=4
a['a']=5
a[1]=4
for i in set(a.values()):
    print(i)

就比如这样，只会输出5,4

需要注意的是**set **函数的返回值是集合数据类型，类似于去重后的列表，并非是一个字典或者列

表之类的数据结构，这就导致了我们无法使用括号对返回的集合进行调用，但可以使用pop等自

带的方法

4.1 嵌套

多种数据结构之间可以互相嵌套，比如可以在列表中存储字典，或者在字典中存储列表，这种方式

被成为嵌套

比如如下的嵌套

b=[1,2]
a={"a":b}
print(a['a'][0])

各种数据结构之间都可以互相进行嵌套，具体的使用就不多加说明了

4.2 用户输入

我们第一个要学习的输入函数是input()，该函数让程序暂停，等待用户输入一些文本，获取用户

输入后，再将其传递给你需要的变量，input中的传递数值为想让在用户输入数据时看到的内容和

，具体的使用如下

a=input("输入你的内容:")
print(a)

这是一个简单的示例，终端会显示传递的内容

需要注意的是，当你的提示内容过多时，可以使用字符串拼接符+分开定义然后进行连接。

还需要注意的是input将你的输入全部看作了字符串，也都将其以字符串的形式存储，我们通过

type函数就可以看出

<class 'str'>

如果想要单纯输入一个数字然后在后续进行运算呢？这时使用input明显就不够了

这时候就得使用int函数了

a=int()
print(type(a))

输出1输出结果是：<class 'int'> 由此可见将输入的值看作了int类型

int()可以通过直接传入参数来代替输入过程，但需要记住的时，传入的参数可以是int类型的数

字，也可也是字符串类型的数字，无论是什么类型，必须是数字，在传入后int会将其统一更改成

int类型

比如：

a=int("1")
print(type(a))

传入的是字符类型的1,

输出显示是int类型

4.3 while循环

while循环的使用和其他语言没有区别

i = 0
while i < 2:
    i = i+1
    print(i)

包括continue和break的使用都和cpp没有任何区别

4.5 函数的关键字参数

python中的函数和别的语言中的函数有一点区别，但区别不大，具体的区别在于函数的定义方式，其他基本和其

余语言相同

def fun():
    print(1)
fun()

这是python中对简单函数的使用

传递的实参分为位置实参和关键字实参

位置实参就是传统写程序时传入的那种，根据先后位置决定实参和形参的对应关系，python像其他的编程语言一

样，还可以使用关键字参数，关键参数不像位置参数一样严格按照位置决定实参形参对应，而是由对应的值对应关

系决定

def fun(b, a):
    print(b)


fun(a=1, b=2)

输出结果为2，由此可见关键字参数的用法

关键字形参和位置形参结合时，关键字形参不能出现在位置形参之前，且关键字形参必须和实参位置对应

比如以下这种

def fun(a, c, b,):
    print(a, c, b)


fun(1, 1, b=1)

无论是改变形参顺序还是实参顺序都不可以

4.6 形参的默认值

编写函数时，可以给每个形参指定默认值，在调用函数中给形参提供了实参时，python将使用指定的实参值，否

则将使用形参的默认值

具体的操作如下

def fun(b, a=1):
    print(a)


fun(2 )

在本例中，由于在不使用关键字实参时都是使用位置实参的，所以我们并没有给形参a传递参数，所以此时的a用

的是默认参数1，故输出结果为1

4.7 传递列表

我们向函数传递的参数不仅仅可以是整数，浮点或者字符串等基础数据类型，也可也向函数

传递列表，元组等数据类型。

举个简单的例子

def fun(li):
    for i in li:
        print(i)


a = [1, 2, 3]
fun(a)

传递给函数后，形参中的数据和原本也是相同的

但我们需要注意的是，与其他语言不同,python中传入的列表形参如果在函数中对其发生了改变，对应的实参也会

发生改变，我的理解是直接将实参的地址传递过去，所以在函数中操作的是列表本身而不是复制,为什么是这样

呢，这又要联系到上几节我们提到的可变数据类型和不可变数据类型了，对于可变数据类型，比如列表，我们可以

直接更改其本身的值，传递给函数的是其地址，对于不可变数据结构，比如整形变量，我们更改其值的过程其实是

新创建了一个空间放了更改后的值，之前的值也没有销毁，变量的指向更改为了新的值的存贮地址罢了，当我们把

不可变数据类型传递给函数时，传递的也是值而不是地址，所以对形参的改变无法实际更改实参。

既然我们知道了列表传递给函数会修改其本身，那有没有什么办法不让其修改呢？参考之前的内容，这时候可以使

用列表的切片，具体的使用方式如下。

def fun(b):
    b[0] = 2


a = [0]
fun(a[:])
print(a[0])

这样传递的是切片的地址，更改的是切片的值。

4.8 传递任意数量的形参

如果我们不确定要传递几个数值该怎么办呢，以下方式可以帮你解决这个问题

def fun(*a):
    print(a)


fun(1, 2, 3)

我们给fun函数传递了3个实参，但fun函数似乎只定义了一个形参,这样是不是有问题呢？事实上不是这样的，我们

定义的形参a前面加了星号，该操作让形参a变成了一个空的元组，所有传递的实参都会存储在这个元组中，无论

有多少个。

我们可以将其与位置参数结合使用

def fun(b, *a):
    print(b)
    print(a)


fun("num", 1, 2, 3)

在元组形参a前加了个形参，该参数会根据位置读取传入的第一个数据Num,后续的一系列数字才会传入到*a

中，所以要注意，如果要用元组实参a和位置实参结合，其要放在最后。

我们在形参前面加一个星号是元组，当我们加两个星号就变成了字典

我们还可以让其和关键字参数结合，但由于位置参数不能出现在关键字参数之后，且任意数量的形参必须放在最后

所以导致关键字实参只能进入任意数量形参中

4.9 将函数与模块

我们可以将写好的函数和主程序分开存储，然后在主程序中导入对应的模块，实现代码块和主程序分离。

我们在运行程序时解释器是直接将模块中的代码直接全部移动到对应的文件中，所以我们不仅可以用模块存储函

数，还可以存储其余的内容，我们世界实际导入的是指定模块的所有成员，包括变量，函数，类等，在使用时需要

用该模块名作为前缀，在导入与使用变量，函数，类的方法完全相同，以下我只介绍函数，其余就不多加介绍了

使用方式：

先将写好函数的文件保存，假设该文件叫fun1.py，里面存在一个func函数，我们在与他同一目录下的另一python

文件比如pri.py中，如果想要调用该文件，需要按下述操作进行

import fun1
fun1.func()

可能一个模块中含有很多函数，但我们也许只想用其中的一个函数，并不想全部调用，这时候应该怎么办呢？

python是支持导入特定的函数的

还是以上面那个情况为例子，我们可以单独只导入func函数

from fun1 import func
func()

这样就可以直接使用了，而且不需要在调用时指明调用的模块名

如果我们要使用的函数与我们主程序中的函数名发生冲突，应该怎么办呢？这时候我们可以使用as对函数进行重

命名，使用方式如下

from fun1 import func as fuuu
fuuu()

如果我们导入的是整个模块，但模块名又太长，我们使用时不是很方便，这时候可以选择给模块进行指名，例如：

import fun1 as funnn
funnn.func()

我们可以一次性导入所有的函数，此时调用函数时不需要指定模块，因为所有函数都已经导入，

from fun1 import *
func()

但由于是全部导入，故可以与主程序原有函数发生冲突，所以不推荐该方式导入函数

5.0创建类和使用类

python自然和其余编程语言一样，也存在类，使用起来也差不多，举一个简单的例子

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age


my_dog = Dog('name', 1)
print(my_dog.name, my_dog.age)

__init__是一个实例函数，，用来初始化对象，会在对象被创建后调用

与__init__类似，还存在__new__，这是一个类方法，在创建对象时被调用

也就是说，如果一个类中同时定义了__init__和__new__函数，则会先调用后者再调用前者，这是和其他语言的

构造函数不同之处

self是指向对象本身的变量，在使用过程中是不需要传入的，但需要写在形参的首位，不能随意更换位置

由于python的变量不需要定义可以直接使用，所以python中也就省去了其他语言中定义成员变量的部分，创建对

象时使用上__init__，如果你没有定义，则可以调用python的默认构造函数进行对象的建立，就是最基

础的类名()形式，自然也不用传参。如果你同时定义了复数个__init__函数，则会根据参数的情况进行匹配，

如果匹配上的有复数个，则会调用最后一个