关于android:快速入门Python基础知识

读完本篇文章后，可对 Python 语言个性、编码格调有肯定理解，并可写出简略的 Python 程序。

一、装置与运行

各个系统的 Python 装置教程请自行查阅材料，这里不再赘述。

查看 Python 版本，在命令行输出 python 即可，同时会进入命令行交互模式，能够在这里执行 python 命令。

如果电脑中装置了 python2.x 和 python3.x 两个版本，输出 python 运行的是 2.x 版本。想运行 3.x，则需输出 python3。

在命令行输出 python：

Solo-mac:~ solo$ python
Python 2.7.10 (default, Aug 17 2018, 19:45:58)
[GCC 4.2.1 Compatible Apple LLVM 10.0.0 (clang-1000.0.42)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

在命令行输出 python3：

Solo-mac:~ solo$ python3
Python 3.7.0 (v3.7.0:1bf9cc5093, Jun 26 2018, 23:26:24)
[Clang 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

输出 exit() 即可退出命令行模式。

命令行运行 python 文件

如果是写好了一个 python 文件，想通过命令行运行它，进入这个目录，在命令行输出 python 文件名.py 即可。

比方桌面上有个文件 hello.py，内容是打印一句话：

print("Hello, Python")

想运行它，先进入 Desktop 目录，再在命令行输出 python hello.py 就能运行：

Solo-mac:Desktop solo$ python hello.py
Hello, Python

二、变量和简略数据类型

2.1 变量命名规定

• 变量名只能蕴含字母、数字和下划线。变量名能够字母或下划线打头，但不能以数字打 头，例如，可将变量命名为 message\_1，但不能将其命名为 1\_message。
• 变量名不能蕴含空格，但可应用下划线来分隔其中的单词。例如，变量名 greeting\_message 可行，但变量名 greeting message 会引发谬误。
• 不要将 Python 关键字和函数名用作变量名，即不要应用 Python 保留用于非凡用处的单词，如 print。
• 变量名应既简短又具备描述性。例如，name 比 n 好，student\_name 比 s\_n 好，name\_length 比 length\_of\_persons\_name 好。
• 慎用小写字母 l 和大写字母 O，因为它们可能被人错看成数字 1 和 0。

变量名应该是小写的，尽管没有强制规定，然而约定俗称的规定。

2.2 字符串

字符串就是一系列字符。在 Python 中，用引号括起的都是字符串，其中的引号能够是单引号，也能够是双引号，还能够同时应用。如：

"This is a string." 
'This is also a string.'
"I love'python'"

2.2.1 字符串的简略运算

上面介绍字符串的简略运算。

title()

title()以首字母大写的形式显示每个单词，行将每个单词的首字母都改为大写。

>>> name = 'solo coder'
>>> name.title()
'Solo Coder'

upper()、lower()

将字符串改为全副大写或全副小写。

>>> name
'solo coder'
>>> name.upper()
'SOLO CODER'
>>> name.lower()
'solo coder'
>>> name
'solo coder'

留神：title()、upper()、lower() 均不扭转原字符串，只是输入了一个新的字符串。

2.2.2 合并（拼接）字符串

Python 应用加号 (+) 来合并字符串。

>>> first = 'solo'
>>> last = 'coder'
>>> full = first + ' ' + last
>>> full
'solo coder'

2.2.3 应用制表符或换行符来增加空白

在编程中，空白泛指任何非打印字符，如空格、制表符和换行符。

要在字符串中增加制表符，可应用字符组合 \t，要在字符串中增加换行符，可应用字符组合 \n。

>>> print('\tPython')
    Python
>>> print('Hello,\nPython')
Hello,
Python

2.2.4 删除空白

rstrip() 删除右侧空白，lstrip() 删除左侧空白，strip() 删除两端空白。

>>> msg = 'Python'
>>> msg
'Python'
>>> msg.rstrip()
'Python'
>>> msg.lstrip()
'Python'
>>> msg.strip()
'Python'
>>> msg
'Python'

留神执行完去空格命令后，再打印出 msg，还是原来的字符串，这阐明 strip() 也不扭转原来的字符串。

2.2.5 Python 2 中的 print 语句

在 Python 2 中，print 语句的语法稍有不同:

>>> python2.7
>>> print "Hello Python 2.7 world!" 
Hello Python 2.7 world!

在 Python 2 中，无需将要打印的内容放在括号内。从技术上说，Python 3 中的 print 是一个函数，因而括号必不可少。有些 Python 2 print 语句也蕴含括号，但其行为与 Python 3 中稍有不同。简略地说，在 Python 2 代码中，有些 print 语句蕴含括号，有些不蕴含。

2.3 数字

2.3.1 整数

在 Python 中，可对整数执行加 (+) 减(-)乘 (*) 除(/)运算。

>>> 2 + 3 
5
>>> 3 - 2 
1
>>> 2 * 3 
6
>>> 3 / 2 
1.5

Python 还反对运算秩序，因而你可在同一个表达式中应用多种运算。你还能够应用括号来修 改运算秩序，让 Python 按你指定的秩序执行运算，如下所示:

>>> 2 + 3*4
14
>>> (2 + 3) * 4 20

2.3.2 浮点数

Python 将带小数点的数字都称为浮点数。大多数编程语言都应用了这个术语，它指出了这样一个事实: 小数点可呈现在数字的任何地位。

从很大水平上说，应用浮点数时都无需思考其行为。你只需输出要应用的数字，Python 通常都会按你冀望的形式解决它们:

>>> 0.1 + 0.1
0.2
>>> 0.2 + 0.2 9 0.4
>>>2 * 0.1
0.2
>>>2 * 0.2
0.4

但须要留神的是，后果蕴含的小数位数可能是不确定的:

>>> 0.2 + 0.1 
0.30000000000000004 
>>> 3 * 0.1 
0.30000000000000004

所有语言都存在这种问题，没有什么可放心的。Python 会尽力找到一种形式，以尽可能准确地示意后果，但鉴于计算机外部示意数字的形式，这在有些状况下很难。前面将会学习更多的解决形式。

2.3.3 应用函数 str()防止类型谬误

如果用数字跟字符串拼接，就会呈现类型谬误。为防止这个问题，能够应用 str() 将数字转换为字符串再进行操作。

>>> age = 18
>>> print('my age is' + age)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str
>>> print('my age is' + str(age))
my age is 18

2.3.4 Python 2 中的整数

在 Python 2 中，将两个整数相除失去的后果稍有不同:

>>> python2.7 
>>> 3 / 2
1

Python 返回的后果为 1，而不是 1.5。在 Python 2 中，整数除法的后果只蕴含整数局部，小数部 分被删除。请留神，计算整数后果时，采取的形式不是四舍五入，而是将小数局部间接删除。

在 Python 2 中，若要防止这种状况，务必确保至多有一个操作数为浮点数，这样后果也将为 浮点数:

>>> 3 / 2
1
>>> 3.0 / 2
1.5
>>> 3 / 2.0 
1.5
>>> 3.0 / 2.0 
1.5

从 Python 3 转而用 Python 2 或从 Python 2 转而用 Python 3 时，这种除法行为经常会令人蛊惑。应用或编写同时应用浮点数和整数的代码时，肯定要留神这种异样行为。

2.3.5 正文

在 Python 中，正文用井号 (#) 标识。井号前面的内容都会被 Python 解释器疏忽。如

# 向大家问好
print("Hello Python people!")

三、列表

列表由一系列按特定顺序排列的元素组成。

在 Python 中，用方括号 ([]) 来示意列表，并用逗号来分隔其中的元素。

>>> list = []
>>> list.append('haha')
>>> list.append('heihei')
>>> list.append('hehe')
>>> list
['haha', 'heihei', 'hehe']
>>> list[0]
'haha'

获取最初一个元素能够用 -1，如 list[-1] 是获取最初一个元素，list[-2] 是获取倒数第二个元素。

3.1 列表的增删改查

3.1.1 批改元素

批改元素间接用索引批改

>>> list[0] = 'nihao'
>>> list
['nihao', 'heihei', 'hehe']

3.1.2 增加元素

能够在开端增加，也能够在任意地位插入。

在开端增加：append

>>> list.append('wa')
>>> list
['nihao', 'heihei', 'hehe', 'wa']

插入：insert

>>> list.insert(1, 'hello')
>>> list
['nihao', 'hello', 'heihei', 'hehe', 'wa']

3.1.3 删除元素

删除有三种形式：

• del：按索引删除
• pop()：删除列表最初一个元素并返回最初一个元素的值。也能够传索引删除任意地位的值。
• remove()：按值删除

>>> list
['nihao', 'hello', 'heihei', 'hehe', 'wa']
>>> del list[1]
>>> list
['nihao', 'heihei', 'hehe', 'wa']
>>> list.pop()
'wa'
>>> list.remove('hehe')
>>> list
['nihao', 'heihei']

给 pop() 传索引删除其余地位的值

>>> list
['nihao', 'heihei']
>>> list.pop(0)
'nihao'
>>> list
['heihei']

留神：

办法 remove()只删除第一个指定的值。如果要删除的值可能在列表中呈现屡次，就须要应用循环来判断是否删除了所有这样的值。

如果你不确定该应用 del 语句还是 pop()办法，上面是一个简略的判断规范: 如果你要从列表中删除一个元素，且不再以任何形式应用它，就应用 del 语句; 如果你要在删除元素后还能持续应用它，就应用办法 pop()。

3.2 组织列表

本节将介绍列表的排序、反转、计算长度等操作。

列表的排序次要有两种形式：

• 应用办法 sort()对列表进行永久性排序
• 应用函数 sorted()对列表进行长期排序

3.2.1 应用办法 sort()对列表进行永久性排序

应用 sort() 办法将扭转原列表。如果要反转排序，只需向 sort()办法传递参数 reverse=True。

>>> list
['zhangsan', 'lisi', 'bob', 'alex']
>>> list.sort()
>>> list
['alex', 'bob', 'lisi', 'zhangsan']
>>> list.sort(reverse=True)
>>> list
['zhangsan', 'lisi', 'bob', 'alex']

3.2.2 应用函数 sorted()对列表进行长期排序

函数 sorted() 让你可能按特定程序显示列表元素，同时不影响它们在列表中的原始排列程序。

如果要反转排序，只需向 sorted() 传递参数 reverse=True。

>>> list = ['douglas','alex','solo','super']
>>> sorted(list)
['alex', 'douglas', 'solo', 'super']
>>> list
['douglas', 'alex', 'solo', 'super']
>>> sorted(list, reverse=True)
['super', 'solo', 'douglas', 'alex']
>>> list
['douglas', 'alex', 'solo', 'super']

3.2.3 反转列表

要反转列表元素的排列程序，可应用办法 reverse()。reverse() 也会扭转原始列表。

reverse() 只会按原来的程序反转，不会进行额定的按字母排序。

>>> list
['douglas', 'alex', 'solo', 'super']
>>> list.reverse()
>>> list
['super', 'solo', 'alex', 'douglas']

3.2.4 确定列表的长度

应用函数 len()可疾速获悉列表的长度。

>>> list
['super', 'solo', 'alex', 'douglas']
>>> len(list)
4

3.3 操作列表

3.3.1 循环

应用 for…in 循环。

python 以缩进来辨别代码块，所以须要正确的缩进

>>> cats
['super', 'solo', 'alex', 'douglas']
>>> for cat in cats:
...     print(cat)
...
super
solo
alex
douglas

3.3.2 range()

Python 函数 range()让你可能轻松地生成一系列的数字。

>>> for value in range(1,5):
...     print(value)
...
1
2
3
4

留神：range() 会产生蕴含第一个参数但不蕴含第二个参数的一系列数值。

应用 range() 创立列表

>>> numbers = list(range(1,6))
>>> numbers
[1, 2, 3, 4, 5]

range() 还能够指定步长。上面的例子生成了从 0 开始，到 11 的偶数：

>>> nums = list(range(0,11,2))
>>> nums
[0, 2, 4, 6, 8, 10]

3.3.3 对列表简略的计算

有几个专门用于解决数字列表的 Python 函数。

• min()：计算最小值
• max()：计算最大值
• sum()：计算总和

>>> numbers
[1, 2, 3, 4, 5]
>>> min(numbers)
1
>>> max(numbers)
5
>>> sum(numbers)
15

3.3.4 列表解析

列表解析将 for 循环和创立新元素的代码合并成一行，并主动附加新元素。

>>> squares = [value**2 for value in range(1,11)]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

要应用这种语法，首先指定一个描述性的列表名，如 squares; 而后，指定一个左方括号，并定义一个表达式，用于生成你要存储到列表中的值。在这个示例中，表达式为 value ** 2，它计 算平方值。接下来，编写一个 for 循环，用于给表达式提供值，再加上右方括号。在这个示例中，for 循环为 for value in range(1,11)，它将值 1~10 提供给表达式 value ** 2。请留神，这里的 for 语句开端没有冒号。

3.4 切片

要创立切片，可指定要应用的第一个元素和最初一个元素的索引。与函数 range()一样，Python 在达到你指定的第二个索引后面的元素后进行。要输入列表中的前三个元素，须要指定索引 0~3，这将输入别离为 0、1 和 2 的元素。

>>> names = ['aa','bb','cc','dd']
>>> print(names[1:4])
['bb', 'cc', 'dd']

如果你没有指定第一个索引，Python 将主动从列表结尾开始:

>>> print(names[:4])
['aa', 'bb', 'cc', 'dd']

如果没有指定终止索引，将主动取到列表开端

>>> print(names[2:])
['cc', 'dd']

也能够应用正数索引，比方返回最初三个元素

>>> print(names[-3:])
['bb', 'cc', 'dd']

遍历切片

>>> for name in names[1:3]:
...     print(name)
...
bb
cc

3.5 复制列表

能够应用切片来疾速复制列表，不指定开始索引和完结索引。

>>> names
['aa', 'bb', 'cc', 'dd']
>>> names2 = names[:]
>>> names2
['aa', 'bb', 'cc', 'dd']

用切片复制进去的新列表，跟原来的列表是齐全不同的列表，扭转其实一个不会影响另一个列表。

>>> names.append('ee')
>>> names
['aa', 'bb', 'cc', 'dd', 'ee']
>>> names2
['aa', 'bb', 'cc', 'dd']

而如果简略的通过赋值将 names 赋值给 names2，就不能失去两个列表，实际上它们都指向了同一个列表。如果扭转其中一个，另一个也将被扭转。

>>> names
['aa', 'bb', 'cc', 'dd']
>>> names2 = names
>>> names2
['aa', 'bb', 'cc', 'dd']
>>> names.append('ee')
>>> names
['aa', 'bb', 'cc', 'dd', 'ee']
>>> names2
['aa', 'bb', 'cc', 'dd', 'ee']

3.6 元组

Python 将不能批改的值称为不可变的，而不可变的列表被称为元组。

元组看起来犹如列表，但应用圆括号而不是方括号来标识。定义元组后，就能够应用索引来拜访其元素，就像拜访列表元素一样。

>>> food = ('apple', 'orange')
>>> food[0]
'apple'
>>> food[1]
'orange'
>>> food[1] = 'banana'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

遍历用法跟列表统一。

四、条件判断

每条 if 语句的外围都是一个值为 True 或 False 的表达式，这种表达式被称为条件测试。

• 查看是否相等，用 ==
• 查看是否不相等，用 !=
• 数字比拟 >、<、>=、<=
• 多个条件与 and
• 多个条件或 or

• 判断列表是否蕴含某元素 in

  >>> names
  ['aa', 'bb', 'cc', 'dd', 'ee']
  >>> 'bb' in names
  True
  

• 判断列表是否不蕴含某元素

  >>> names
  ['aa', 'bb', 'cc', 'dd', 'ee']
  >>> 'ff' not in names
  True
  

if 语句

简略的 if-else

>>> a = 10
>>> if a > 10:
...     print('hello')
... else:
...     print('bye')
...
bye

if-elif-else

>>> if a<5:
...     print(a<5)
... elif 5<a<10:
...     print('5<a<10')
... else:
...     print('a>10')
...
a>10

五、字典

在 Python 中，字典是一系列键 - 值对。每个键都与一个值相关联，你能够应用键来拜访与之相关联的值。与键相关联的值能够是数字、字符串、列表乃至字典。事实上，可将任何 Python 对象用作字典中的值。

5.1 字典的增删改查

应用字典

在 Python 中，字典用放在花括号 {} 中的一系列键 - 值对示意。

>>> user = {'name':'bob', 'sex':'male', 'age':20}
>>> user
{'name': 'bob', 'sex': 'male', 'age': 20}

拜访字典中的值

要获取与键相关联的值，可顺次指定字典名和放在方括号内的键。

>>> user
{'name': 'bob', 'sex': 'male', 'age': 20}
>>> user['name']
'bob'
>>> user['age']
20

增加键值对

字典是一种动静构造，可随时在其中增加键—值对。

>>> user['city']='beijing'
>>> user
{'name': 'bob', 'sex': 'male', 'age': 20, 'city': 'beijing'}

批改字典中的值

要批改字典中的值，可顺次指定字典名、用方括号括起的键以及与该键相关联的新值。

>>> cat = {}
>>> cat['color'] = 'white'
>>> cat['age'] = 4
>>> cat
{'color': 'white', 'age': 4}
>>> cat['age'] = 6
>>> cat
{'color': 'white', 'age': 6}

删除键值对

对于字典中不再须要的信息，可应用 del 语句将相应的键—值对彻底删除。应用 del 语句时，必须指定字典名和要删除的键。

>>> del cat['color']
>>> cat
{'age': 6}

5.2 遍历字典

字典可用于以各种形式存储信息，因而有多种遍历字典的形式: 可遍历字典的所有键—值对、键或值。

遍历所有键值对 items()

>>> cat
{'age': 6, 'color': 'white', 'city': 'beijing'}
>>> for k,v in cat.items():
...     print(k + '-' + str(v))
...
age-6
color-white
city-beijing

通过 for k,v in cat.items() 的形式遍历所有的键值对，k 代表键，v 代表值。

留神：即使遍历字典时，键—值对的返回程序也与存储程序不同。Python 不关怀键—值对的存储程序，而只跟踪键和值之间的关联关系。

遍历所有键 keys()

如果不须要用值，能够用 keys() 遍历出所有的键。

>>> cat
{'age': 6, 'color': 'white', 'city': 'beijing'}
>>> for k in cat.keys():
...     print(k.title())
...
Age
Color
City

下面的例子打印出了 cat 的所有键，用字符串的 title() 办法使每个单词的首字母大写。

遍历字典时会默认遍历所有的键，for k in cat.keys() 和 for k in cat 的成果一样。

按程序遍历所有键，可用 sorted() 排序，这让 Python 列出字典中的所有键，并在遍历前对这个列表进行排序。

>>> for k in sorted(cat.keys()):
...     print(k.title())
...
Age
City
Color

遍历所有值 values()

>>> for value in cat.values():
...     print(str(value))
...
6
white
beijing

如果须要剔除反复项，能够应用 set()

>>> cat
{'age': 6, 'color': 'white', 'city': 'beijing', 'city2': 'beijing'}
>>> for value in cat.values():
...     print(str(value))
...
6
white
beijing
beijing
>>> for value in set(cat.values()):
...     print(str(value))
...
beijing
white
6

5.3 嵌套

能够在列表中嵌套字典、在字典中嵌套列表以及在字典中嵌套字典。这里就不演示了。

六、用户输出和 while 循环

6.1 用户输出

函数 input()让程序暂停运行，期待用户输出一些文本。获取用户输出后，Python 将其存储在一个变量中，以不便你应用。

>>> msg = input('Please input your name:')
Please input your name: solo
>>> msg
'solo'

如果你应用的是 Python 2.7，应应用函数 raw\_input()来提醒用户输出。这个函数与 Python 3 中的 input()一样，也将输出解读为字符串。

Python 2.7 也蕴含函数 input()，但它将用户输出解读为 Python 代码，并尝试运行它们。如果你应用的是 Python 2.7，请应用 raw\_input()而不是 input()来获取输出。

如果想将输出的内容转换为数字，能够用 int() 来转换。

6.2 while 循环

for 循环用于针对汇合中的每个元素都一个代码块，而 while 循环不断地运行，直到指定的条件不满足为止。

>>> num = 1
>>> while num <= 5:
...     print(str(num))
...     num += 1
...
1
2
3
4
5

break

要立刻退出 while 循环，不再运行循环中余下的代码，也不论条件测试的后果如何，可应用 break 语句。break 语句用于管制程序流程，可应用它来管制哪些代码即将执行，哪些代码行不执行，从而让程序按你的要求执行你要执行的代码。

continue

要返回到循环结尾，并依据条件测试后果决定是否继续执行循环，可应用 continue 语句，它不像 break 语句那样不再执行余下的代码并退出整个循环。

七、函数

Python 用关键字 def 来定义函数，函数名以冒号 : 结尾，冒号之后的缩进里的内容都是函数体。

>>> def greet():
...     print('Hello World!')
...
>>> greet()
Hello World!

7.1 函数参数

能够向函数传递参数。上面的例子向函数 greet() 传递了个参数 name。其中 name 是形参，solo 是实参。

>>> def greet(name):
...     print('Hello,' + name)
...
>>> greet('solo')
Hello,solo

向函数传递实参的形式很多，可应用地位实参，这要求实参的程序与形参的程序雷同; 也可应用关键字实参，其 中每个实参都由变量名和值组成; 还可应用列表和字典。

地位实参

你调用函数时，Python 必须将函数调用中的每个实参都关联到函数定义中的一个形参。为此，最简略的关联形式是基于实参的程序。这种关联形式被称为地位实参。

>>> def student(name, age):
...     print('Hello, My name is' + name + ', I am' + str(age) + 'years old')
...
>>> student('solo', 18)
Hello, My name is solo, I am 18 years old

依照形参定义的程序传递的实参就称为地位实参。

关键字实参

关键字实参是传递给函数的名称—值对。关键字实参让你无需思考函数调用中的实参程序，还分明地指出了函数调用中各个值的用处。

>>> student(age=18, name='solo')
Hello, My name is solo, I am 18 years old

接着地位实参中的例子，student(name, age) 办法第一个参数是 name，第二个参数是 age。咱们用关键字实参指明传递的是哪一个，即便程序写乱了失去的后果也不会乱。

默认值

编写函数时，可给每个形参指定默认值。在调用函数中给形参提供了实参时，Python 将应用指定的实参值; 否则，将应用形参的默认值。因而，给形参指定默认值后，可在函数调用中省略相应的实参。应用默认值可简化函数调用，还可分明地指出函数的典型用法。

>>> def student(name, age=18):
...     print('Hello, My name is' + name + ', I am' + str(age) + 'years old')
...
>>> student('bob')
Hello, My name is bob, I am 18 years old
>>> student('nicole')
Hello, My name is nicole, I am 18 years old
>>> student('bob', 20)
Hello, My name is bob, I am 20 years old

如上，给 student() 函数定义的第二个参数 age 设置了默认值 18，如果调用时只传一个参数，无论传的是什么 age 都是 18。当传两个参数时，传递的实参就会笼罩掉默认值。

留神：应用默认值时，在形参列表中必须先列出没有默认值的形参，再列出有默认值的实参。这让 Python 仍然可能正确地解读地位实参。

7.2 返回值

函数并非总是间接显示输入，相同，它能够解决一些数据，并返回一个或一组值。函数返回 的值被称为返回值。在函数中，可应用 return 语句将值返回到调用函数的代码行。返回值让你可能将程序的大部分沉重工作移到函数中去实现，从而简化主程序。

>>> def student(name):
...     return name
...
>>> name = student('solo')
>>> name
'solo'

返回字典

函数可返回任何类型的值，包含列表和字典等较简单的数据结构。例如，上面的函数承受姓名和年龄，并返回一个示意人的字典:

>>> def build_person(name,age):
...     person = {'name':name, 'age':age}
...     return person
...
>>> p = build_person('solo',18)
>>> p
{'name': 'solo', 'age': 18}

7.3 传递任意数量的实参

有时候，你事后不晓得函数须要承受多少个实参，好在 Python 容许函数从调用语句中收集任意数量的实参。

>>> def person(*args):
...     print(args)
...
>>> person('name','age','address')
('name', 'age', 'address')

下面定义了一个函数 person()，只有一个形参 *args。形参名 *args 中的星号让 Python 创立一个名为 args 的空元组，并将收到的所有值都封装到这个元组中。

联合应用地位实参和任意数量实参

如果要让函数承受不同类型的实参，必须在函数定义中将接收任意数量实参的形参放在最初。Python 先匹配地位实参和关键字实参，再将余下的实参都收集到最初一个形参中。

>>> def person(city, *args):
...     print('city:' + city + ', other args:')
...     for value in args:
...             print(value)
...
>>> person('beijing', 'name', 'age', 'tel')
city: beijing, other args:
name
age
tel

函数 person() 有两个形参，第一个 city 是一般的地位实参，第二个 *args 是可变参数。

应用任意数量的关键字实参

有时候，须要承受任意数量的实参，但事后不晓得传递给函数的会是什么样的信息。在这种状况下，可将函数编写成可能承受任意数量的键—值对——调用语句提供了多少就承受多少。一个这样的示例是创立用户简介: 你晓得你将收到无关用户的信息，但不确定会是什么样的信息。

def build_profile(first, last, **user_info):
    profile = {}
    profile['first_name'] = first
    profile['last_name'] = last

    for key,value in user_info.items():
        profile[key] = value

    return profile

user = build_profile('steven', 'bob', city='beijing', age=18)

print(user)

执行代码，输入后果是：

{'first_name': 'steven', 'last_name': 'bob', 'city': 'beijing', 'age': 18}

7.4 导入导出

能够将函数存储在被称为模块的独立文件中，再将模块导入到主程序中。import 语句容许在以后运行的程序文件中应用模块中的代码。

7.4.1 导入整个模块

模块是扩大名为.py 的文件，蕴含要导入到程序中的代码。

cat.py

def eat(food):
    print('I am cat, I eat' + food)

animal.py

import cat

cat.eat('fish')

控制台输入

I am cat, I eat fish

7.4.2 导入特定的函数

你还能够导入模块中的特定函数，这种导入办法的语法如下:

from module_name import function_name 

通过用逗号分隔函数名，可依据须要从模块中导入任意数量的函数:

from module_name import function_0, function_1, function_2 

下面的例子只导入 cat.py 中的 eat() 办法

from cat import eat

eat('fish')

失去雷同的后果。

7.4.3 应用 as 给函数指定别名

如果要导入的函数的名称可能与程序中现有的名称抵触，或者函数的名称太长，可指定简短而举世无双的别名——函数的另一个名称，相似于外号。要给函数指定这种非凡外号，须要在导入它时这样做。

from cat import eat as cat_eat

cat_eat('fish')

将 cat.py 中的 eat() 办法导入并指定了别名 cat_eat，应用时能够间接用别名应用。

7.4.4 应用 as 给模块指定别名

你还能够给模块指定别名。通过给模块指定简短的别名，让你 可能更轻松地调用模块中的函数。

通用语法：import module_name as mn

import cat as c

c.eat('fish')

7.4.5 导入模块中的所有函数

应用星号 (*) 运算符可让 Python 导入模块中的所有函数:

cat.py

def eat(food):
    print('I am cat, I eat' + food)


def run():
    print('cat run')

animal.py

from cat import *

eat('fish')
run()

输入后果

I am cat, I eat fish
cat run

因为导入 了每个函数，可通过名称来调用每个函数，而无需应用句点表示法。然而，应用并非本人编写的 大型模块时，最好不要采纳这种导入办法: 如果模块中有函数的名称与你的我的项目中应用的名称相 同，可能导致意想不到的后果: Python 可能遇到多个名称雷同的函数或变量，进而笼罩函数，而 不是别离导入所有的函数。

最佳的做法是，要么只导入你须要应用的函数，要么导入整个模块并应用句点表示法。这能 让代码更清晰，更容易浏览和了解。

7.5 函数编写指南

• 应给函数指定描述性名称
• 函数名应只蕴含小写字母和下划线
• 每个函数都应蕴含简要地论述其性能的正文，该正文应紧跟在函数定义前面，并采纳文档字符串格局。

• 给形参指定默认值时，等号两边不要有空格:

  def function_name(parameter_0, parameter_1='default value')
  

  对于函数调用中的关键字实参，也应遵循这种约定:

  function_name(value_0, parameter_1='value')
  

• 如果程序或模块蕴含多个函数，可应用两个空行将相邻的函数离开，这样将更容易晓得前一个函数在什么中央完结，下一个函数从什么中央开始。
• 所有的 import 语句都应放在文件结尾，惟一例外的情景是，在文件结尾应用了正文来形容整个程序。

八、类

8.1 创立和应用类

class Cat():
    def __init__(self, name, color):
        self.name = name
        self.color = color

    def eat(self):
        print('cat' + self.name + 'color' + self.color + ', now eat')

    def run(self):
        print('cat' + self.name + 'color' + self.color + ', now run')


my_cat = Cat('Spring', 'white')
print(my_cat.name)
print(my_cat.color)
my_cat.eat()
my_cat.run()

下面创立了类 Cat，并实例化了 my_cat，而后调用了类的办法 eat() 和 run()。输入后果：

Spring
white
cat Spring color white, now eat
cat Spring color white, now run

类中的函数称为办法。__init__() 是函数的构造方法，每档创立新实例时 Python 都会主动运行它。留神构造方法名字必须是这个，是规定好的。

下面的例子中__init__(self, name, color) 有三个形参，第一个形参 self 必不可少，还必须位于其余形参的后面。其余的形参能够依据须要调整。self 是一个指向实例自身的援用，让实例可能拜访类中的属性和办法。

还能够通过实例间接拜访属性：my_cat.name。但在其余语言中并不倡议这样做。

在 Python 2.7 中创立类

在 Python 2.7 中创立类时，须要做轻微的批改——在括号内蕴含单词 object:

class ClassName(object):

8.2 类的属性

8.2.1 给属性设置默认值

类中的每个属性都必须有初始值，哪怕这个值是 0 或空字符串。在有些状况下，如设置默认值时，在办法__init__() 内指定这种初始值是可行的; 如果你对某个属性这样做了，就无需蕴含为它提供初始值的形参。

从新定义 Cat，在构造方法中给属性 age 设置默认值。

class Cat():
    def __init__(self, name, color):
        self.name = name
        self.color = color
        self.age = 3

    def eat(self):
        print('cat' + self.name + 'color' + self.color + ', now eat')

    def run(self):
        print('cat' + self.name + 'color' + self.color + ', now run')

    def print_age(self):
        print('cat`s age is' + str(self.age))

8.2.2 批改属性的值

能够以三种不同的形式批改属性的值：间接通过实例进行批改，通过办法进行设置。

1. 间接批改属性的值

要批改属性的值，最简略的形式是通过实例间接拜访它。

class Cat():
    def __init__(self, name, color):
        self.name = name
        self.color = color
        self.age = 3

    def eat(self):
        print('cat' + self.name + 'color' + self.color + ', now eat')

    def run(self):
        print('cat' + self.name + 'color' + self.color + ', now run')

    def print_age(self):
        print('cat`s age is' + str(self.age))


my_cat = Cat('Spring', 'white')

my_cat.print_age()
my_cat.age = 4
my_cat.print_age()

输入后果为

cat`s age is 3
cat`s age is 4

上例间接通过 my_cat.age = 4 批改了 age 属性的值。

2. 通过办法批改属性的值

再来更新代码，退出 update_age() 办法来批改 age 的属性。

class Cat():
    def __init__(self, name, color):
        self.name = name
        self.color = color
        self.age = 3

    def eat(self):
        print('cat' + self.name + 'color' + self.color + ', now eat')

    def run(self):
        print('cat' + self.name + 'color' + self.color + ', now run')

    def print_age(self):
        print('cat`s age is' + str(self.age))

    def update_age(self, age):
        self.age = age


my_cat = Cat('Spring', 'white')
my_cat.print_age()
my_cat.update_age(10)
my_cat.print_age()

运行代码输入：

cat`s age is 3
cat`s age is 10

8.3 继承

一个类继承另一个类时，它将主动取得另一个类的所有属性和办法; 原有的类称为父类，而新类称为子类。子类继承了其父类的所有属性和办法，同时还能够定义本人的属性和办法。

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

    def run(self):
        print('Animal' + self.name + 'run')

class Cat(Animal):
    def __init__(self, name, age):
        super().__init__(name, age)


cat = Cat('Tony', 2)
cat.run()

运行程序，输入：

Animal Tony run

先定义了类 Animal，又定义了 Cat 继承自 Animal。Animal称为父类，Cat 称为子类。通过输入能够验证，子类继承了父类的办法。

在子类的构造方法中要先实现父类的构造方法：super().__init__(name, age)。

还能够给子类定义本人的办法，或者重写父类的办法。

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

    def run(self):
        print('Animal' + self.name + 'run')

class Cat(Animal):
    def __init__(self, name, age):
        super().__init__(name, age)

    def play(self):
        print('Cat' + self.name + 'play')

    def run(self):
        print('Cat' + self.name + 'run')


cat = Cat('Tony', 2)
cat.run()
cat.play()

咱们来批改下程序，Animal 类不变，Cat 类还是继承了 Animal，但定义了本人的办法 play() 并重写了父类办法 run()。运行程序，失去输入：

Cat Tony run
Cat Tony play

Python2.7 中的继承

在 Python 2.7 中，继承语法稍有不同，ElectricCar 类的定义相似于上面这样:

class Car(object):
    def __init__(self, make, model, year):
        --snip--
    
class ElectricCar(Car):
    def __init__(self, make, model, year):
        super(ElectricCar, self).__init__(make, model, year)
        --snip--

函数 super()须要两个实参: 子类名和对象 self。为帮忙 Python 将父类和子类关联起来，这些实参必不可少。另外，在 Python 2.7 中应用继承时，务必在定义父类时在括号内指定 object。

8.4 导入类

当一个文件过长时，能够将其中一部分代码抽离进来，而后导入到主文件中。

导入形式有多种：

• 导入单个类

  如果 car.py 里定义了类 Car

  from car import Car
  

• 从一个模块中导入多个类

  如果 car.py 蕴含了三个类 Car，Battery 和 ElectricCar。

  只导入一个类：

  from car import ElectricCar
  

  导入多个类，两头用逗号隔开：

  from car import Car, ElectricCar
  

• 导入整个模块

  还能够导入整个模块，再应用句点表示法拜访须要的类。这种导入办法很简略，代码也易于浏览。因为创立类实例的代码都蕴含模块名，因而不会与以后文件应用的任何名称发生冲突。

  import car
  my_car = car.Car()
  

• 导入模块中的所有类

  要导入模块中的每个类，可应用上面的语法:

  from module_name import *
  

  不举荐应用这种导入形式，其起因有二。

  首先，如果只有看一下文件结尾的 import 语句，就 能分明地晓得程序应用了哪些类，将大有裨益; 但这种导入形式没有明确地指出你应用了模块中 的哪些类。这种导入形式还可能引发名称方面的困惑。如果你不小心导入了一个与程序文件中其 他货色同名的类，将引发难以诊断的谬误。这里之所以介绍这种导入形式，是因为尽管不举荐使 用这种形式，但你可能会在他人编写的代码中见到它。

  须要从一个模块中导入很多类时，最好导入整个模块，并应用 module\_name.class\_name 语法 来拜访类。这样做时，尽管文件结尾并没有列出用到的所有类，但你分明地晓得在程序的哪些地 方应用了导入的模块; 你还防止了导入模块中的每个类可能引发的名称抵触。

九、文件和异样

9.1 从文件中读取数据

要应用文本文件中的信息，首先须要将信息读取到内存中。为此，你能够一次性读取文件的全部内容，也能够以每次一行的形式逐渐读取。

9.1.1 读取整个文件

with open('test.txt') as file_obj:
    contents = file_obj.read()
    print(contents)

open() 用于关上一个文件，参数为文件的门路。

关键字 with 在不再须要拜访文件后将其敞开。有了 with 你只管关上文件，并在须要时应用它，Python 自会 在适合的时候主动将其敞开。

相比于原始文件，该输入惟一不同的中央是开端多了一个空行。为何会多出这个空行呢? 因为 read() 达到文件开端时返回一个空字符串，而将这个空字符串显示进去时就是一个空行。要删除多进去的空行，可在 print 语句中应用 rstrip()。

文件门路能够是相对路径，也能够是绝对路径。

9.1.2 逐行读取

with open('test.txt') as file_obj:
    for line in file_obj:
        print(line.rstrip())

要以每次一行的形式查看文件，可对文件对象应用 for 循环。

9.2 写入文件

with open('test.txt', 'w') as file_obj:
    file_obj.write("I love python")

在这个示例中，调用 open()时提供了两个实参，第一个实参也是要关上的文件的名称；第二个实参 (‘w’) 通知 Python，咱们要以写入模式关上这个文件。

可选模式：

• r：只读。
• w : 只写。如果文件不存在则创立，如果文件存在则先清空，再写入。
• a：附加模式，写入的内容追加到原始文件前面。如果文件不存在则创立。
• r+：可读可写。

如果你省略了模式实参，Python 将以默认的只读模式关上文件。

9.3 异样

异样是应用 try-except 代码块解决的。try-except 代码块让 Python 执行指定的操作，同时通知 Python 产生异样时怎么办。

try:
    print(5/0)
except ZeroDivisionError:
    print("You can't divide by zero!")

else 代码块

try:
    print(5/0)
except ZeroDivisionError:
    print("You can't divide by zero!")
else:
    print("no exception")

如果 try 中的代码运行胜利，没有出现异常，则执行 else 代码块中的代码。

9.4 用 json 存储数据

Python 中应用 json.dump() 和 json.load() 来存储和读取 json 文件。

import json

userInfo = {'username': 'jack', 'age': 18}

with open('test.txt', 'w') as obj:
    json.dump(userInfo, obj)

with open('test.txt') as obj:
    content = json.load(obj)
    print(content)

上例中用 json.dump() 把数据存入到了 test.txt 中，又用 json.load() 把数据从文件中取出并打印。

留神应用前先导入 json 模块。

十、单元测试

先定义一个拼接名字的函数 name_function.py

def get_formatted_name(first, last):
    full_name = first + ' ' + last
    return full_name.title()

再写测试类来测试这个函数

import unittest
from name_function import get_formatted_name

class NamesTestCase(unittest.TestCase):

    def test_name_function(self):
        full_name = get_formatted_name('david', 'alex')
        self.assertEqual(full_name, 'David Alex')


unittest.main()

测试类要继承 unittest.TestCase，通过 self.assertEqual 断言是否失去的后果和预期相等。

常见的断言办法

setUp() 办法

如果你在 TestCase 类中蕴含了办法 setUp()，Python 将先运行它，再运行各个以 test\_打头的办法。

通常用于做一些初始化操作。

总结

pyton 的语言个性和编码格调是比拟通俗易懂的，也是根底，这篇文章也只是后期学习 python 的一个铺垫，次要你要学会怎么去使用好，同样这也是一个过程和一个很好的开始。

本文转自 https://juejin.cn/post/6844903765410070535，如有侵权，请分割删除。