Python基础回顾

1、python关键字

python3.7中有33个关键字。所有关键字区分大小写。

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

>>> import keyword

>>> print(keyword.kwlist)

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', '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']

2、python中的数据类型

• 数字：int、float、complex类。

int和float不难理解，complex是指复数，例如：a=1+2j

• 列表：是项目的有序序列，列表允许是不同的类型。

a=[1,2,’p’]

• 元组（Tuple）：是项目的有序序列，与列表（List）相同。唯一的区别是元组是不可变的。元组一旦创建就不能修改。元组用于写保护数据，因为不能动态修改，所以通常比列表快。

t=(5,’p’,1+3j)

• 字符串：是Unicode字符的序列，用单引号或双引号来表示字符串，三引号表示多行字符串。
• 集合（Set）：是项目的无序集合，每个元素都是唯一的（没有重复项），且不能修改。

a={2,3,5,1,0}

• 字典：是键值对的无序集合。适用于大量数据。

d={1:’val’,’key’:2}

3、python输入/输出

>>>a = 5

>>>print('a的值为', a)

# a的值为5

>>>print(1, 2, 3, 4)

# 1 2 3 4

>>>print(1, 2, 3, 4, sep='*')

# 1*2*3*4

>>>print(1, 2, 3, 4, sep='#', end='&')

# 1#2#3#4&

>>>print('x的值为{}，y的值为{}'.format(3,6))

# x的值为5，y的值为10

>>>print('I love {0} and {1}'.format('bread','butter'))

# I love bread and butter

>>>print('I love {1} and {0}'.format('bread','butter'))

# I love butter and bread

>>> x = 12.3456789

>>> print('x的值为 %3.2f' %x)

x的值为 12.35

>>> print('x的值为 %3.4f' %x)

x的值为 12.3457

4、python运算符

x = 15

y = 4

# 输出: x + y = 19

print('x + y =',x+y)

# 输出: x - y = 11

print('x - y =',x-y)

# 输出: x * y = 60

print('x * y =',x*y)

# 输出: x / y = 3.75

print('x / y =',x/y)

# 输出: x // y = 3

print('x // y =',x//y)

# 输出: x ** y = 50625

print('x ** y =',x**y)

5、range()函数

print(range(10))

#range(0, 10)

print(list(range(10)))

#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(list(range(2, 8))) #2~7

#[2, 3, 4, 5, 6, 7]

print(list(range(2, 20, 3))) #range(start,stop,step_size)

#[2, 5, 8, 11, 14, 17]

6、for循环带else

digits = [0, 1, 5]

for i in digits:

    print(i)

else:

print("没有剩余的项目.")

#输出结果

#0

#1

#5

#没有剩余的项目.

7、while循环带else

counter = 0

while counter < 3:

    print("内部循环")

    counter = counter + 1

else:

print("else语句")

#内部循环

#内部循环

#内部循环

#else语句

8、python匿名函数（Lambda）

在python中，匿名函数是没有定义名称的函数。def在python中使用关键字定义普通函数，使用关键字lambda定义匿名函数，因此匿名函数也称为lambda函数。Lambda函数可以具有任意数量的参数，但是只能有一个表达式。

double = lambda x: x * 2

print(double(5))

#10

• Lambda函数与filter()函数一起使用：

# 程序从列表中过滤出偶数项

my_list = [1, 5, 4, 6, 8, 11, 3, 12]

new_list = list(filter(lambda x: (x%2 == 0) , my_list))

print(new_list)

#[4, 6, 8, 12]

• Lambda函数与map()函数一起使用：

# 使用map()将列表中的每个项加倍

my_list = [1, 5, 4, 6, 8, 11, 3, 12]

new_list = list(map(lambda x: x * 2 , my_list))

print(new_list)

#[2, 10, 8, 12, 16, 22, 6, 24]

9、非局部变量

非局部变量用于未定义局部作用域的嵌套函数。该变量既不能在局部范围内，也不能在全局范围内，而是要在主函数内嵌套函数外的局部变量，该变量由主函数定义，可以通过嵌套函数内部使用nonlocal关键字重新定义，然后就可以修改这个外部局部变量的值了。因此这个变量称为非局部变量。

10、全局关键字

python中global关键字的基本规则是：

• 当在函数内部创建变量时，默认情况下它是局部的。
• 当在函数外部定义变量时，默认情况下它是全局的，且函数方法只能访问访问不能修改，该变量不必使用global关键字。
• 可以使用global关键字在函数内部读写全局变量。

11、python列表

# 嵌套列表

n_list = ["Happy", [2,0,1,5]]

# 嵌套索引

# 输出: a

print(n_list[0][1])

# 输出: 5

print(n_list[1][3])

my_list = ['p','r','o','g','r','a','m','i','z']

# 从第3元素至第5个元素

print(my_list[2:5])

# 从开始到第4个元素

print(my_list[:-5])

# 第6个元素至结束

print(my_list[5:])

# 元素开始到结束

print(my_list[:])

# 值列表

odd = [2, 4, 6, 8]

# 改变第一个元素

odd[0] = 1

# 输出: [1, 4, 6, 8]

print(odd)

# 改变第2到第4项

odd[1:4] = [3, 5, 7]

# 输出: [1, 3, 5, 7]

print(odd)

odd = [1, 3, 5]

odd.append(7)

# 输出: [1, 3, 5, 7]

print(odd)

odd.extend([9, 11, 13])

# 输出: [1, 3, 5, 7, 9, 11, 13]

print(odd)

odd = [1, 3, 5]

# 输出: [1, 3, 5, 9, 7, 5]

print(odd + [9, 7, 5])

#输出: ["re", "re", "re"]

print(["re"] * 3)

odd = [1, 9]

odd.insert(1,3)

# 输出: [1, 3, 9]

print(odd)

odd[2:2] = [5, 7]

# 输出: [1, 3, 5, 7, 9]

print(odd)

my_list = ['p','r','o','b','l','e','m']

# 删除一项

del my_list[2]

# 输出: ['p', 'r', 'b', 'l', 'e', 'm']

print(my_list)

# 删除多个项目

del my_list[1:5]

# 输出: ['p', 'm']

print(my_list)

# 删除所有列表

del my_list

# Error: List not defined

print(my_list)

my_list = ['p','r','o','b','l','e','m']

my_list.remove('p')

# 输出: ['r', 'o', 'b', 'l', 'e', 'm']

print(my_list)

# 输出: 'o'

print(my_list.pop(1))

# 输出: ['r', 'b', 'l', 'e', 'm']

print(my_list)

# 输出: 'm'

print(my_list.pop())

# 输出: ['r', 'b', 'l', 'e']

print(my_list)

my_list.clear()

# 输出: []

print(my_list)

>>> my_list = ['p','r','o','b','l','e','m']

>>> my_list[2:3] = []

>>> my_list

['p', 'r', 'b', 'l', 'e', 'm']

>>> my_list[2:5] = []

>>> my_list

['p', 'r', 'm']

12、python继承

python继承语法：

class BaseClass:

#基类主体

class DerivedClass(BaseClass):

#派生类的主体

13、python的特殊函数

以双下划线开头的函数在python中称为特殊函数。

例如__init__()函数和__str__()函数。

14、python中的多线程

计算机程序是指令的集合，而进程就是这些指令的执行。线程是进程的子集。

python多线程示例：

import threading

def print_hello_three_times():

for i in range(3):

print("Hello")

def print_hi_three_times():

for i in range(3):

print("Hi")

t1 = threading.Thread(target=print_hello_three_times)

t2 = threading.Thread(target=print_hi_three_times)

t1.start()

t2.start()

#执行结果

#Hello

#Hello

#Hi

#Hello

#Hi

#Hi

15、python中的命名空间

名称（标识符）是赋予对象的名称。python中一切都是对象，名称是访问基础对象的一种方式。在python中，命名空间可以认作为是已定义的每个名称到对应对象的映射。

例如：当我们执行赋值操作时x=1，1是一个存储在内存中的对象，而x是与之关联的名称。我们可以通过内置函数获取某些对象的地址（在内存中）id()。

16、python迭代器

迭代器是可以迭代的对象，在python中Iterator是一个可以迭代的对象，一个将返回数据的对象，一次返回一个元素。python迭代器对象必须实现两个特殊方法，__iter__()和__next__()统称为迭代器协议。

17、python生成器

简而言之，生成器是一个函数，它返回一个对象。如果一个函数包含至少一个yield语句（它可能包含其他yield或return语句），那么它就成为一个生成器函数；yield和return都将从函数返回一些值。不同之处在于，当return语句完全终止一个函数时，yield语句会暂停该函数保存其所有状态，然后在后续调用时继续执行。

生成器函数与常规函数的区别：

• 生成器函数包含一个或多个yield语句。
• 调用时，它返回一个对象（迭代器），但不会立即开始执行。
• 像__iter__()和__next__()这样的方法会自动实现。因此，我们可以使用next()来遍历项目。
• 一旦函数产生了结果，函数就会暂停，控制就会转移给调用者。
• 局部变量及其状态在连续调用之间被记住。
• 最后，当函数终止时，在进一步调用时会自动引发Stoplteration。

18、python闭包

在另一个函数内部定义的函数称为嵌套函数。嵌套函数可以访问封闭范围的变量。在python中，默认情况下，这些非本地变量是只读的，并且我们必须将它们明确声明为非本地变量（使用nonlocal关键字）才能进行修改。

通俗来讲，闭包是一个函数，是一个可以访问别的函数（嵌套函数上一级函数）作用域里面的变量的函数。

19、python装饰器

所谓装饰器就是在原来的函数中添加了一些新功能，这类似于包装，装饰器（函数）充当包装器。被装饰的物品（里面的被包装的函数）的性质不会改变。但装饰器包装后的函数会增加一些想要的样式。

def make_pretty(func):

    def inner():

        print("我被装饰了")

        func()

    return inner

def ordinary():

    print("我是普通的函数")

>>> ordinary()

#我是普通的函数
# 我们来装饰一下这个普通的函数
>>> pretty = make_pretty(ordinary)

>>> pretty()
#我被装饰了
#我是普通的函数

20、python中主函数

python中的main()函数是一个特殊函数，它是程序文件的执行点。__name__变量是一个特殊的内置python变量，它显示当前模块的名称，根据执行python文件的位置，它具有不同的值。当我们将程序作为脚本运行时，变量的值__name__设置为__main__。所以程序执行。

21、python中的pip

pip是python的标准软件包管理器。