关于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 文件名.py 即可。

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

print("Hello, Python")

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

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

变量名只能蕴含字母、数字和下划线。变量名能够字母或下划线打头，但不能以数字打头，例如，可将变量命名为 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。

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

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

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

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

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() 均不扭转原字符串，只是输入了一个新的字符串。

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

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

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

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

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

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

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

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

在 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 语句蕴含括号，有些不蕴含。

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

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

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

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

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 会尽力找到一种形式，以尽可能准确地示意后果，但鉴于计算机外部示意数字的形式，这在有些状况下很难。前面将会学习更多的解决形式。

如果用数字跟字符串拼接，就会呈现类型谬误。为防止这个问题，能够应用 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

在 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 时，这种除法行为经常会令人蛊惑。应用或编写同时应用浮点数和整数的代码时，肯定要留神这种异样行为。

在 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] 是获取倒数第二个元素。

批改元素间接用索引批改

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

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

在开端增加：append

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

插入：insert

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

删除有三种形式：

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()。

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

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

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

应用 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']

函数 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']

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

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

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

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

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

应用 for…in 循环。

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

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

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]

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

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

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

列表解析将 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 语句开端没有冒号。

要创立切片，可指定要应用的第一个元素和最初一个元素的索引。与函数 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

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

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

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-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 对象用作字典中的值。

在 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}

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

遍历所有键值对 `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

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

函数 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() 来转换。

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

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

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

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

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

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

能够向函数传递参数。上面的例子向函数 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 仍然可能正确地解读地位实参。

函数并非总是间接显示输入，相同，它能够解决一些数据，并返回一个或一组值。函数返回的值被称为返回值。在函数中，可应用 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}

有时候，你事后不晓得函数须要承受多少个实参，好在 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}

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

模块是扩大名为.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

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

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')

失去雷同的后果。

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

from cat import eat as cat_eat

cat_eat('fish')

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

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

通用语法：import module_name as mn

import cat as c

c.eat('fish')

应用星号 (*) 运算符可让 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 可能遇到多个名称雷同的函数或变量，进而笼罩函数，而不是别离导入所有的函数。

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

应给函数指定描述性名称
函数名应只蕴含小写字母和下划线
每个函数都应蕴含简要地论述其性能的正文，该正文应紧跟在函数定义前面，并采纳文档字符串格局。
给形参指定默认值时，等号两边不要有空格:
```
def function_name(parameter_0, parameter_1='default value')
```
对于函数调用中的关键字实参，也应遵循这种约定:
```
function_name(value_0, parameter_1='value')
```
如果程序或模块蕴含多个函数，可应用两个空行将相邻的函数离开，这样将更容易晓得前一个函数在什么中央完结，下一个函数从什么中央开始。
所有的 import 语句都应放在文件结尾，惟一例外的情景是，在文件结尾应用了正文来形容整个程序。

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 中创立类时，须要做轻微的批改——在括号内蕴含单词 object:

class ClassName(object):

类中的每个属性都必须有初始值，哪怕这个值是 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))

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

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

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

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

在 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。

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

导入形式有多种：

导入单个类

如果 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 语法来拜访类。这样做时，尽管文件结尾并没有列出用到的所有类，但你分明地晓得在程序的哪些地方应用了导入的模块; 你还防止了导入模块中的每个类可能引发的名称抵触。

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

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

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

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

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

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

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

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

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

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

可选模式：

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

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

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

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

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

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

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 断言是否失去的后果和预期相等。

办法	用处
assertEqual(a, b)	核实 a == b
assertNotEqual(a, b)	核实 a != b
assertTrue(x)	核实 x 为 True
assertFalse(x)	核实 x 为 False
assertIn(item, list)	核实 item 在 list 中
assertNotIn(item, list)	核实 item 不在 list 中

`setUp()` 办法

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

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

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

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

一、装置与运行

命令行运行 python 文件

二、变量和简略数据类型

2.1 变量命名规定

2.2 字符串

2.2.1 字符串的简略运算

title()

upper()、lower()

2.2.2 合并（拼接）字符串

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

2.2.4 删除空白

2.2.5 Python 2 中的 print 语句

2.3 数字

2.3.1 整数

2.3.2 浮点数

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

2.3.4 Python 2 中的整数

2.3.5 正文

三、列表

3.1 列表的增删改查

3.1.1 批改元素

3.1.2 增加元素

3.1.3 删除元素

3.2 组织列表

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

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

3.2.3 反转列表

3.2.4 确定列表的长度

3.3 操作列表

3.3.1 循环

3.3.2 range()

3.3.3 对列表简略的计算

3.3.4 列表解析

3.4 切片

3.5 复制列表

3.6 元组

四、条件判断

if 语句

五、字典

5.1 字典的增删改查

应用字典

拜访字典中的值

增加键值对

批改字典中的值

删除键值对

5.2 遍历字典

遍历所有键值对 items()

遍历所有键 keys()

遍历所有值 values()

5.3 嵌套

六、用户输出和 while 循环

6.1 用户输出

6.2 while 循环

break

continue

七、函数

7.1 函数参数

地位实参

关键字实参

默认值

7.2 返回值

返回字典

7.3 传递任意数量的实参

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

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

7.4 导入导出

7.4.1 导入整个模块

7.4.2 导入特定的函数

7.4.3 应用 as 给函数指定别名

7.4.4 应用 as 给模块指定别名

7.4.5 导入模块中的所有函数

7.5 函数编写指南

八、类

8.1 创立和应用类

在 Python 2.7 中创立类

8.2 类的属性

8.2.1 给属性设置默认值

8.2.2 批改属性的值