python的基本使用

---

print 功能

print 字符串

• python 中 print 字符串 要加’ ‘(单引号)或者” “(双引号)。
• 要显示引号：加反斜杠\ 或者外层用双引号

>>> print('hello world')
hello world
>>> print("hello world 2")
hello world 2
print('I\'m')
I'm
print("I'm")
I'm

print 字符串叠加

可以使用 + 将两个字符串链接起来。

>>> print('Hello world' + ' Hello Gong Kong')
Hello world Hello Gong Kong

字符串不能直接+数字,可以包在' '里面或者通过str()转化成string

>>>print('apple'+4)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: must be str, not int
>>>print('apple'+'4')
apple4
>>>print('apple'+str(4))
apple4

int()可以把整数的string转化为int，而小数形式的string需要通过float()转化

>>>print(int('2.2')+2)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '2.2'
>>>print(int('2')+2)
4
>>>print(float('2.2')+2)
4.2

简单运算

可以直接print 加法+,减法-,乘法*,除法/.
注意：字符串不可以直接和数字相加，否则出现错误。

>>> print(1 + 1)
2
>>> print(3 - 1)
2
>>> print(3 * 4)
12
>>> print(12 / 4)
3.0
>>> print('iphone' + 4)
Traceback (most recent call last):
File "<pyshell#11>", line 1, in <module>
print('iphone' + 4)
TypeError: must be str, not int

int()和 float()；当int()一个浮点型数时，int会保留整数部分,比如 int(1.9),会输出1,而不是四舍五入。

>>> print(int('2') + 3) # int为定义整数型 
5
>>> print(int(1.9)) # 当定义为一个浮点型数时，int会保留整数部分
1
>>>print(int(2.6)+2)
4
>>> print(float('1.2') + 3) # float是浮点型，可以把字符串转换为小数
4.2

基础数学运算

基本的加减乘除

python可以直接运算数字，也可以加print 进行运算。

>>> 1 + 1
2
>>> 2 - 1
1
>>> 2 * 3
6
>>> 4 / 3
1.3333333333333333

^ 与 *

python当中^{符号，区别于其他语言，在python中，}用两个表示，如3的平方为3*2 , 3表示立方，4表示4次方，依次类推。

>>> 3 ** 2  # **2表示3的二次方
9
>>> 3 ** 3  # **3表示3的三次方
27

取余数 %

取余数符号为“%”。

>>> 8 % 3
2

取整//

>>>9//4
2

Python比较运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 true.
<>	不等于 - 比较两个对象是否不相等	(a <> b) 返回 true。这个运算符类似 != 。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。	(a < b) 返回 true。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 true。

Python赋值运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

Python逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

Python成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

Python身份运算符

身份运算符用于比较两个对象的存储单元

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

变量 variable

自变量命名规则

可以将一个数值，或者字符串串附值给自变量，如apple=1中，apple为自变量的名称，1为自变量的值。 也可以将字符串赋值给自变量

>>>apple='iphone'
>>>pear=10
>>>print(apple)
iphone
>>>print(pear)
10

自变量名称区分大小写；如果需要用多个单词来表示自变量，需要加下划线，如

>>>apple_2016 = 'iphone7 plus and new macbook'
>>>print(apple_2016)  # 输出值为iphone7 plus and new macbook
iphone7 plus and new macbook

可在自变量后面进行运算,运算结果存储在自变量里

>>>c=1+2+3
>>>c
6

python允许一次定义多个自变量，如

>>>a, b, c = 11, 12, 13
>>>print(a, b, c) # 输出值为11, 12, 13
11 12 13

while和for循环

---

while循环

基本使用

主要结构如下：

while condition:
    expressions

其中 condition为判断条件，在 Python 中就是True 和False 其中的一个，如果为 True， 那么将执行 expressions语句,否则将跳过该 while 语句块接着往下执行。

实例

比如要打印出 0 - 9 的所有数据：

condition = 0
while condition < 10:
    print(condition)
    condition = condition + 1

输出的结果将是 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 第一行设置condition的 初始值为 0，在进行 while 判断的时候0 < 10为 True，将会执行 while 内部 的代码，首先先打印出该值，然后将 condition 值加 1，至此将完成一次循环；再 condition的值与 10进行比较，仍然为True，重复如上过程，至到condiiton等于 10 后，不满足condition < 10的条件（False），将不执行 while 内部的内容，所以10不会被打印。

注意点

在使用 while 句法的时候一定要注意在循环内部一定要修改判断条件的值，否则程序的while部分将永远执行下去。
如果按以下程序执行，程序将一直打印出 I’m True，要停止程序，使用ctrl + c终止程序。

while True:
    print("I'm True")

高级主题

在 Python 中除了常规比较操作

• 小于（<)
• 大于 (>)
• 不大于 (<=)
• 不小于 (>=)
• 等于 (==)
• 不等于 (!=)

会返回True 和 False值，其他操作也会返回 True 和 False。

1.数字

整数和浮点数也能进行 Boolean数据操作，如果该值等于0或者0.0将会返回False，其余的返回True。

condition = 10
while condition:
    print(condition)
    condition=-1

输出的结果将会是 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 在这里condition在while语句中，如果该值大于0，那么将会返回为True，执行循环内部语句，直至 condition等于0，返回 False。

2.None 类型

如果 while 后面接着的语句数据类型None, 将会返回 False。

3.集合类型

在Python中集合类型有list、tuple、dict和set等，如果该集合对象作为while判断语句， 如果集合中的元素数量为 0，那么将会返回False，否则返回True。
下列程序将会返回 9, 8, 7, 6, 5, 4, 3, 2, 1, 0，程序首先判断列表是否空，如果不为空，则打印出最后一个内容，然后使用切片操作去掉最后一个元素，并更新列表；如此重复，直至列表为空。

a = range(10)
while a:
    print(a[-1])
    a = a[:len(a)-1]

for循环

基本使用

在Python中的基本使用方法如下：

for item in sequence:
    expressions

sequence为可迭代的对象，item为序列中的每个对象。

实例

example_list = [1, 2, 3, 4, 5, 6, 7, 12, 543, 876, 12, 3, 2, 5]
for i in example_list:
    print(i)

以下程序输出的结果为1,2,3,4,5,6,7,12,543,876,12,3,2,5, 内容依次为 example_list中的每一个元素。注意 Python 是使用缩进表示程序的结构，如果程序如下编写

example_list = [1, 2, 3, 4, 5, 6, 7, 12, 543, 876, 12, 3, 2, 5]
for i in example_list:
    print(i)
    print("inner of for")
print("outer of for')

那么每次循环都会输出 inner of for，在循环结束后，输出outer of for一次。

进阶

range使用

在 Python 内置了工厂函数，range 函数将会返回一个序列，总共有三种使用方法

1.range(start, stop)

其中start 将会是序列的起始值，stop为结束值，但是不包括该值，类似数学中的表达 [start, stop),左边为闭区间，右边为开区间。

for i in range(1, 10):
    print(i)  # 上述表达将会返回1-9所有整数，但不包括10

2.range(stop)

如果省略了 start 那么将从 0开始，相当于range(0, stop)。

3.range(start, stop, step)

step 代表的为步长，即相隔的两个值的差值。从 start 开始，依次增加 step 的值，直至等于或者大于 stop。

for i in range(0, 13, 5):
    print(i)  # 将会输出0,5,10

高级主题

4.1内置集合

Python共内置了list、tuple 、dict和set四种基本集合，每个集合对象都能够迭代。
tuple 类型

tup = ('python', 2.7, 64)
for i in tup:
    print(i)  # 程序将以此按行输出‘python’, 2.7, 64

dictionary 类型
字典在迭代的过程 中将key作为可迭代的对象返回。
（注意字典中 key是乱序的，也就是说和插入的顺序是不一致的。
如果想要使用顺序一致的字典，请使用collections 模块中的 OrderedDict对象。）——似乎是旧版问题
下列程序输出的结果为：lan python,version 2.7,platform 64,a b,c 1,1 2,1 v
。

dic = {'lan': 'python', 'version': 2.7, 'platform': 64}
for key in dic:
    print(key, dic[key])

dic={}
dic['a']='b'
dic['c']=1
dic[1]=2
dic['1']='v'
for key in dic:
    print(key, dic[key])

set 类型

set 集合将会去除重复项。输出的 结果也不是按照输入的顺序。
下列程序将会输出 python, python3, python2。

s = set(['python', 'python2', 'python3', 'python'])   
for item in s:
    print(item)

迭代器

Python 中的 for句法实际上实现了设计模式中的迭代器模式 ，所以我们自己也可以按照迭代器的要求自己生成迭代器对象，以便在 for 语句中使用。只要类中实现了iter 和next函数，那么对象就可以在for 语句中使用。现在创建 Fibonacci 迭代器对象，以下程序将会输出前 5 个 Fibonacci 数据 1，1，2，3，5。

# define a Fib class
class Fib(object):
    def __init__(self, max):
        self.max = max
        self.n, self.a, self.b = 0, 0, 1

    def __iter__(self):
        return self

    def __next__(self):
        if self.n < self.max:
            r = self.b
            self.a, self.b = self.b, self.a + self.b
            self.n = self.n + 1
            return r
        raise StopIteration()

# using Fib object
for i in Fib(5):
    print(i)

4.3 生成器

除了使用迭代器以外，Python 使用yield 关键字也能实现类似迭代的效果。yield 语句每次执行时，立即返回结果给上层调用者，而当前的状态仍然保留，以便迭代器下一次循环调用。这样做的好处是在于节约硬件资源，在需要的时候才会执行，并且每次只执行一次。

def fib(max):
    a, b = 0, 1
    while max:
        r = b
        a, b = b, a + b
        max -= 1
        yield r

# using generator
for i in fib(5):
    print(i)

将会输出前 5 个 Fibonacci 数据1，1, 2, 3, 5

if 判断

---

if 判断

基本使用

与其他编程语言中的 if 语句一样，使用方法如下

if condition:
    expressions

如果 condition 的值为 True,将会执行 expressions 语句的内容，否则将跳过该语句往下执行。

实例

x = 1
y = 2
z = 3
if x < y:
    print('x is less than y')

上述代码中，if 语句的条件为 x < y 为 True, 那么将执行条件内部语句，程序将输出 x is less than y。 当我们将代码修改为一下

if x < y < z:
    print('x is less than y, and y is less than z')

在这里的条件变成了 x < y < z, 其相当于 x < y and y < z, 如果 and 两边的条件都为 True 那么才会返回 True。 注意这个用法是 python 语言特有，不鼓励 大家写出这样的代码，以便其他语言的程序员能够看懂你的代码。

注意点

在 python 语言中等号的判断使用 == 而不是 =, 因为后一种是赋值语句。

x = 1
y = 2
z = 3
if x = y:
    print('x is equal to y')

如果这样写的话，是有句法错误的，程序将无法执行。当然如果是从 C/C++ 语言转过来的同学，刚才那一句是非常熟悉的，也是我们经常错误的来源。

修改如下

x = 2
y = 2
z = 0
if x == y:
    print('x is equal to y')

因为 x 和 y 都等于2, 所以将会输出 x is equal to y。

if else 判断

基本使用

if condition:
    true_expressions
else:
    false_expressions

当 if 判断条件为 True,执行 true_expressions 语句; 如果为 False，将执行 else 的内部的 false_expressions。

实例

x = 1
y = 2
z = 3
if x > y:
    print('x is greater than y')
else:
    print('x is less or equal to y')

在这个例子中，因为 x > y 将会返回 False, 那么将执行 else 的分支内容。输出 x is less or equal to y

x = 4
y = 2
z = 3
if x > y:
    print('x is greater than y')
else:
    print('x is less or equal y')

在这里，因为 condition 条件为 True, 那么将会输出 x is greater than y。

高级主题

对于从其他编程语言转过来的同学一定非常想知道 python 语言中的三目操作符怎么使用，很遗憾的是 python 中并没有类似 condition ? value1 : value2 三目操作符。然后现实中很多情况下我们只需要简单的判断 来确定返回值，但是冗长的 if-else 语句似乎与简单的 python 哲学不一致。别担心，python 可以通过 if-else 的行内表达式完成类似的功能。

var = var1 if condition else var2

可以这么理解上面这段语句，如果 condition 的值为 True, 那么将 var1 的值赋给 var;如果为 False 则将 var2 的值赋给 var。

worked = True
result = 'done' if worked else 'not yet'
print(result)

首先判断如果 work 为 True,那么将 done 字符串赋给 result，否则将 not yet 赋给 result。 结果将输出 done。

if elif else 判断

基本使用

if condition1:
    true1_expressions
elif condition2:
    true2_expressions
elif condtion3:
    true3_expressions
elif ...
    ...
else:
    else_expressions

如果有多个判断条件，那可以通过 elif 语句添加多个判断条件，一旦某个条件为 True，那么将执行对应的 expression。 并在之代码执行完毕后跳出该 if-elif-else 语句块，往下执行。

实例

x = 4
y = 2
z = 3
if x > 1:
    print ('x > 1')
elif x < 1:
    print('x < 1')
else:
    print('x = 1')
print('finish')

因为 x = 4 那么满足 if 的条件，则将输出 x > 1 并且跳出整个 if-elif-else 语句块，那么紧接着输出 finish。 如果将 x = -2 那么将满足 elif x < 1 这个条件，将输出 x <1, finish。

定义功能

---

def 函数

如果我们用代码实现了一个小功能，但想要在程序代码中重复使用，不能在代码中到处粘贴这些代码，因为这样做违反 了软件工程中 DRY原则。 Python 提供了 函数功能，可以将我们这部分功能抽象成一个函数以方便程序调用，或者提供给其他模块使用。

基本使用

def function_name(parameters):
    expressions

Python 使用 def 开始函数定义，紧接着是函数名，括号内部为函数的参数，内部为函数的 具体功能实现代码，如果想要函数有返回值, 在 expressions 中的逻辑代码中用 return 返回。

实例

def function():
    print('This is a function')
    a = 1+2
    print(a)

上面我们定义了一个名字为 function的函数，函数没有接收参数，所以括号内部为空，紧接着就是 函数的功能代码。如果执行该脚本，发现并没有输出任何输出，因为我们只定义了函数，而并没有执行函数。 这时我们在 Python 命令提示符中输入函数调用 function(), 注意这里调用函数的括号不能省略。那么 函数内部的功能代码将会执行，输出结果：

This is a function
3

如果我们想要在脚本中调用的脚本，只需要在脚本中最后添加函数调用语句

function()

那么在执行脚本的时候，将会执行函数。

函数参数

我们在使用的调用函数的时候，想要指定一些变量的值在函数中使用，那么这些变量就是函数的参数，函数调用的时候， 传入即可。

基本使用

def function_name(parameters):
    expressions

parameters 的位置就是函数的参数，在调用的时候传入即可。

实例

def func(a, b):
    c = a+b
    print('the c is ', c)

在这里定义的一个函数，其参数就是两个数值，函数的功能就是把两个参数加起来。运行脚本后，在 Python 提示符内调用函数 func, 如果不指定参数 func(), 那么将会出错; 输出 func(1, 2)，将 a=1, b=2 传入函数，输出 the c is 3 。所以在调用函数时候，参数个数和位置一定要按照函数定义。如果我们忘记了函数的参数的位置，只知道各个参数的名字，可以在 函数调用的过程中给指明特定的参数 func(a=1, b=2), 这样的话，参数的位置将不受影响，所以 func(b=2,a=1)是同样的 的效果。

函数默认参数

我们在定义函数时有时候有些参数在大部分情况下是相同的，只不过为了提高函数的适用性，提供了一些备选的参数， 为了方便函数调用，我们可以将这些参数设置为默认参数，那么该参数在函数调用过程中可以不需要明确给出。

基本使用

def function_name(para_1,...,para_n=defau_n,..., para_m=defau_m):
    expressions

函数声明只需要在需要默认参数的地方用 = 号给定即可, 但是要注意所有的默认参数都不能出现在非默认参数的前面。

实例

def sale_car(price, color='red', brand='carmy', is_second_hand=True):
    print('price', price,
          'color', color,
          'brand', brand,
          'is_second_hand', is_second_hand,)

在这里定义了一个 sale_car 函数，参数为车的属性，但除了 price 之外，像 color, brand 和 is_second_hand 都是有默认值的，如果我们调用函数 sale_car(1000), 那么与 sale_car(1000, 'red', 'carmy', True) 是一样的效果。当然也可以在函数调用过程中传入特定的参数用来修改默认参数。通过默认参数可以减轻我们函数调用的复杂度。

进阶

3.1 自调用

如果想要在执行脚本的时候执行一些代码，比如单元测试，可以在脚本最后加上单元测试 代码，但是该脚本作为一个模块对外提供功能的时候单元测试代码也会执行，这些往往我们不想要的，我们可以把这些代码放入脚本最后：

if __name__ == '__main__':
    #code_here

如果执行该脚本的时候，该 if 判断语句将会是 True,那么内部的代码将会执行。 如果外部调用该脚本，if 判断语句则为 False,内部代码将不会执行。

3.2 可变参数

顾名思义，函数的可变参数是传入的参数可以变化的，1个，2个到任意个。当然可以将这些 参数封装成一个 list 或者 tuple 传入，但不够 pythonic。使用可变参数可以很好解决该问题，注意可变参数在函数定义不能出现在特定参数和默认参数前面，因为可变参数会吞噬掉这些参数。

def report(name, *grades):
    total_grade = 0
    for grade in grades:
        total_grade += grade
    print(name, 'total grade is ', total_grade)

定义了一个函数，传入一个参数为 name, 后面的参数 *grades 使用了 * 修饰，表明该参数是一个可变参数，这是一个可迭代的对象。该函数输入姓名和各科的成绩，输出姓名和总共成绩。所以可以这样调用函数 report('Mike', 8, 9)，输出的结果为 Mike total grade is 17, 也可以这样调用 report('Mike', 8, 9, 10)，输出的结果为 Mike total grade is 27

3.3 关键字参数

关键字参数可以传入0个或者任意个含参数名的参数，这些参数名在函数定义中并没有出现，这些参数在函数内部自动封装成一个字典(dict).

def portrait(name, **kw):
    print('name is', name)
    for k,v in kw.items():
        print(k, v)

定义了一个函数，传入一个参数 name, 和关键字参数 kw，使用了 ** 修饰。表明该参数是关键字参数，通常来讲关键字参数是放在函数参数列表的最后。如果调用参数 portrait('Mike', age=24, country='China', education='bachelor') 输出:

name is Mike
age 24
country China
education bachelor

通过可变参数和关键字参数，任何函数都可以用 universal_func(*args, **kw) 表达。

变量形式

---

局部变量

在 def 中, 我们可以定义一个局部变量, 这个变量a只能在这个功能 fun中有效, 出了这个功能, a这个变量就不是那个局部的a.

def fun():
    a = 10
    print(a)
    return a+100

print(fun())

"""
10
110
"""

下面这个例子就验证了如果在 fun 外面调用 a, 会报错, 这表明外面的这个 print(a)不能找到那个局部的 a, 只有全局变量再能在外面被调用, 比如 APPLE.全局变量一般大写

APPLY = 100 # 全局变量
def fun():
    a = 10  # 局部变量
    return a+100

print(APPLE)    # 100
print(a)    # 报错, 不能拿到一个局部变量的值

全局变量

那如何在外部也能调用一个在局部里修改了的全局变量呢. 首先我们在外部定义一个全局变量 a=None, 然后再fun()中声明 这个a是来自外部的 a. 声明方式就是 global a. 然后对这个外部的 a修改后, 修改的效果会被施加到外部的 a 上. 所以我们将能看到运行完 fun(), a 的值从 None 变成了 20.

APPLE = 100 # 全局变量
a = None
def fun():
    global a    # 使用之前在全局里定义的 a
    a = 20      # 现在的 a 是全局变量了
    return a+100

print(APPLE)    # 100
print('a past:', a)  # None
print(fun()) #120
print('a now:', a)   # 20

模块安装

安装外部的模块有很多种方式, 不同的系统安装形式也不同. 比如在 Windows 上安装 Python 的一些包, 可能还会要了你的老命. 哈哈.

什么是外部模块

外部模块就是在你 import 什么东西去python 脚本的时候会用到的.

import numpy as np
import matplotlib.pyplot as plt

这里的 Numpy 和 matplotlib 都是外部模块, 需要安装以后才会有的. 他不属于 python 自带的模块.

安装 Numpy

这里我们举例说明, 对于一些科学运算的模块, 比如 numpy, 他的安装方式就有很多。 在 Windows 上, 最简单的方式就安装 Anaconda 这种平台, 他会自带很多必要的外部模块. 安装一个, 省去安装其它的烦恼。
不过我这里要讲的是下载安装包的方式在 Windows 安装. 比如 在 Numpy 安装包的网站中, 你能找到 numpy 的各种版本的安装包。
在 NumPy 1.10.2 这个版本中, 我们能找到适合 Windows 的安装包, 新版中目前还没添加 Windows 的安装包. 然后根据你的系统和 python 版本选择合适的 “exe” 安装包.。下载安装。
如果你是 MacOS 或者 Linux, 这种外部模块, 安装起来就方便多了。在你的电脑 Terminal 上输入一句话, 就能轻松安装.。Windows 好像要经过特殊设置才能实现一样的功能, 具体忘记了… 你可能要查一下. 在我电脑中, Terminal 长这样。

然后只要你在里面输入这种形式就可以安装了.

$ pip install 你要的模块名

比如

$ pip install numpy   # 这是 python2+ 版本的用法
$ pip3 install numpy   # 这是 python3+ 版本的用法

更新外部模块

使用 pip 更新外部模块会十分简单. 主需要在 Terminal 中输入下面的指令就行. 这里的 -U 就是 update 意思.

$ pip install -U numpy   # 这是 python2+ 版本的用法
$ pip3 install -U numpy   # 这是 python3+ 版本的用法

pycharm 模块安装与更新

File->Settings->Project Interpreter

pycharm安装模块

文件读取

\n 换行命令

定义 text为字符串, 并查看使用 \n和不适用\n的区别:

text='This is my first test. This is the second line. This the third '
print(text)  # 无换行命令

"""
This is my first test. This is the second line. This the third
"""

text='This is my first test.\nThis is the second line.\nThis the third line'
print(text)   # 输入换行命令\n，要注意斜杆的方向。注意换行的格式和c++一样

"""
This is my first test.
This is the second line.
This the third line
"""

open 读文件方式

使用open 能够打开一个文件,open 的第一个参数为文件名和路径 ‘my file.txt’, 第二个参数为将要以什么方式打开它, 比如 w为可写方式. 如果计算机没有找到 ‘my file.txt’ 这个文件, w方式能够创建一个新的文件, 并命名为 my file.txt
完整的语法格式为：

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数说明:
file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener:

file

my_file=open('my file.txt','w')   #用法: open('文件名','形式'), 其中形式有'w':write;'r':read.
my_file.write(text)               #该语句会写入先前定义好的 text
my_file.close()                   #关闭文件

open一个同py文件同一个目录的文件的时候，用以下：

txt = open('filtered_words.txt','rb')

也可利用绝对路径

txt = open('E:\\python_project\\test\github\\filtered_words.txt','rb')

用反斜杠

txt = open('E:/python_project/test/github/filtered_words.txt','rb')

mode

t 文本模式 (默认)。
x 写模式，新建一个文件，如果该文件已存在则会报错。
b 二进制模式。
+ 打开一个文件进行更新(可读可写)。
U 通用换行模式（不推荐）。
r 以只读方式打开文件（带r的文件必须先存在）。文件的指针将会放在文件的开头。这是默认模式。
r+ 可读可写,不会创建不存在的文件。如果直接写文件，则从顶部开始写，覆盖之前此位置的内容，如果先读后写，则会在文件最后追加内容。

(每当你open一个文件的时候，都会产生一个文件"指针",这个指针会随你的读写操作而向后移动。初始这个指针是指向文件内容的起始位置，当你运行指令f.read（）时，它会读取文件的所有内容，并将指针从文件起始位置一直移到文件末尾。当你运行指令f.write("你好")前，这个指针是指向当前文件末尾，所以会将“你好”添加在文件末尾，此时指针又移动到“你好”的后面，此时你又输入“世界”，则在指针指向的文件当前位置写入“世界”，此时指针又移动到“世界”的后面。此时，你又运行f.read(),由于此时指针指向的是当前文件的末尾，即指向“世界”的后面，而“世界”后面当然什么内容都没了，故你什么都读取不了，空白)

w+ 可读可写 如果文件存在 则覆盖整个文件不存在则创建 //要close 之后才算完成写入
w 只能写 覆盖整个文件 不存在则创建
a 只能写 从文件底部添加内容 不存在则创建
a+ 可读可写 从文件顶部读取内容 从文件底部添加内容 不存在则创建

encoding 编码方式

1.win系统默认是gbk编码的，所以桌面生成的TXT之类的都是gbk编码的。
2.出现乱码正常都是原文件的编码方式和打开指定的编码不一致所致

\t tab 对齐

使用 \t 能够添加一个tab间隔：

text='\tThis is my first test.\nThis is the \tsecond line.\n\t\tThis is the third line'
print(text) 
"""
    This is my first test.
This is the     second line.
        This is the third line

"""

给文件增加内容

我们先保存一个已经有3行文字的 “my file.txt” 文件, 文件的内容如下:

This is my first test. 
This is the second line.
This the third

然后使用添加文字的方式给这个文件添加一行 “This is appended file.”, 并将这行文字储存在 append_file 里，注意\n的适用性:

append_text='\nThis is appended file.'  # 为这行文字提前空行 "\n"
my_file=open('my file.txt','a')   # 'a'=append 以增加内容的形式打开
my_file.write(append_text)
my_file.close()
""""
This is my first test.
This is the second line.
This the third line.
This is appended file.
""""
#运行后再去打开文件，会发现会增加一行代码中定义的字符串

总结

掌握 append 的用法 ：open('my file.txt','a') 打开类型为 a ，a 即表示 append

读取文件内容 file.read()

使用 file.read() 能够读取到文本的所有内容.

file= open('my file.txt','r') 
content=file.read()  
print(content)

""""
This is my first test.
This is the second line.
This the third line.
This is appended file.    
""""

按行读取 file.readline()

如果想在文本中一行行的读取文本,带换行符, 可以使用 file.readline(), file.readline() 读取的内容和你使用的次数有关, 使用第二次的时候, 读取到的是文本的第二行, 并可以以此类推:

file= open('my file.txt','r') 
content=file.readline()  # 读取第一行
print(content)
""""
This is my first test.
""""
second_read_time=file.readline()  # 读取第二行
print(second_read_time)
"""
This is the second line.
"""

读取所有行 file.readlines()

如果想要读取所有行, 并可以使用像 for 一样的迭代器迭代这些行结果, 我们可以使用 file.readlines(), 将每一行的结果存储在 list 中, 方便以后迭代，注意换行符是包含在字符串的内容中。

file= open('my file.txt','r') 
content=file.readlines() # python_list 形式
print(content)
""""
['This is my first test.\n', 'This is the second line.\n', 'This the third line.\n', 'This is appended file.']
""""
# 之后如果使用 for 来迭代输出:
for item in content:
    print(item)   
"""
This is my first test.
This is the second line.
This the third line.
This is appended file.
"""

去除换行符\n

使用strip()函数去掉每行结束的\n

for line in file.readlines():
    line=line.strip('\n')

strip()函数原型

声明：s为字符串，rm为要删除的字符序列

s.strip(rm) 删除s字符串中开头、结尾处，位于 rm删除序列的字符

s.lstrip(rm) 删除s字符串中开头处，位于 rm删除序列的字符

s.rstrip(rm) 删除s字符串中结尾处，位于 rm删除序列的字符

注意：当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')

class 类

class 类

class 定义一个类

class 定义一个类,类似于定义一个函数, 后面的类别首字母推荐以大写的形式定义，比如Calculator. class可以先定义自己的属性，比如该属性的名称可以写为 name='Good Calculator'. class后面还可以跟def, 定义一个函数. 比如def add(self,x,y): 加法, 输出print(x+y). 其他的函数定义方法一样，注意这里的self 是默认值.

class Calculator:       #首字母要大写，冒号不能缺
    name='Good Calculator'  #该行为class的属性
    price=18
    def add(self,x,y):
        print(self.name)
        result = x + y
        print(result)
    def minus(self,x,y):
        result=x-y
        print(result)
    def times(self,x,y):
        print(x*y)
    def divide(self,x,y):
        print(x/y)

""""
>>> cal=Calculator()  #注意这里运行class的时候要加"()",否则调用下面函数的时候会出现错误,导致无法调用.
>>> cal.name
'Good Calculator'
>>> cal.price
18
>>> cal.add(10,20)
Good Calculator
30
>>> cal.minus(10,20)
-10
>>> cal.times(10,20)
200
>>> cal.divide(10,20)
0.5
>>>
""""

总结

注意定义自变量cal等于Calculator要加括号“()” ,cal=Calculator()否则运行下面函数的时候会出现错误,导致无法调用.

class 类 init 功能

init

init可以理解成初始化class的变量，取自英文中initial 最初的意思.可以在运行时，给初始值附值，

运行c=Calculator('bad calculator',18,17,16,15),然后调出每个初始值的值。看如下代码。

class Calculator:
    name='good calculator'
    price=18
    def __init__(self,name,price,height,width,weight):   # 注意，这里的下划线是双下划线
        self.name=name
        self.price=price
        self.h=height
        self.wi=width
        self.we=weight
""""
>>> c=Calculator('bad calculator',18,17,16,15)
>>> c.name
'bad calculator'
>>> c.price
18
>>> c.h
17
>>> c.wi
16
>>> c.we
15
>>>
""""

如何设置属性的默认值, 直接在def里输入即可，如下:

def __init__(self,name,price,height=10,width=14,weight=16):查看运行结果， 三个有默认值的属性，可以直接输出默认值，这些默认值可以在code中更改, 比如c.wi=17再输出c.wi就会把wi属性值更改为17.同理可推其他属性的更改方法。

class Calculator:
    name='good calculator'
    price=18
    def __init__(self,name,price,height=10,width=14,weight=16): #后面三个属性设置默认值,查看运行
        self.name=name
        self.price=price
        self.h=height
        self.wi=width
        self.we=weight

 """"
>>> c=Calculator('bad calculator',18)
>>> c.h
10
>>> c.wi
14
>>> c.we
16
>>> c.we=17
>>> c.we
17
""""

总结

def __init__(self,name,price,height,width,weight):注意，这里的下划线是双下划线

input 输入

input

variable=input()表示运行后，可以在屏幕中输入一个数字，该数字会赋值给自变量。看代码：

a_input=input('please input a number:')
print('this number is:',a_input)
''''
please input a number:12 #12 是我在硬盘中输入的数字
this number is: 12
''''

input()应用在if语句中.
在下面代码中，需要将input() 定义成整型，因为在if语句中自变量 a_input对应的是1 and 2 整数型。输入的内容和判断句中对应的内容格式应该一致。
也可以将if语句中的1and2定义成字符串，其中区别请读者自定写入代码查看。

a_input=int(input('please input a number:'))#注意这里要定义一个整数型
if a_input==1:
    print('This is a good one')
elif a_input==2:
    print('See you next time')
else:
    print('Good luck')
""""
please input a number:1   #input 1
This is a good one
please input a number:2   #input 2
See you next time
please input a number:3   #input 3 or other number
Good luck
""""

input扩展

用input()来判断成绩

score=int(input('Please input your score: \n'))
if score>=90:
   print('Congradulation, you get an A')
elif score >=80:
    print('You get a B')
elif score >=70:
    print('You get a C')
elif score >=60:
    print('You get a D')
else:
    print('Sorry, You are failed ')

""""
Please input your score:
100   #手动输入
Congradulation, you get an A
""""

元组、列表、字典

元组 列表

Tuple

叫做tuple，用小括号、或者无括号来表述，是一连串有顺序的数字。

a_tuple = (12, 3, 5, 15 , 6)
another_tuple = 12, 3, 5, 15 , 6

List

而list是以中括号来命名的:

a_list = [12, 3, 67, 7, 82]

两者对比

他们的元素可以一个一个地被迭代、输出、运用、定位取值:

for content in a_list:
    print(content)
"""
12
3
67
7
82
"""

for content_tuple in a_tuple:
    print(content_tuple)
"""
12
3
5
15
6
"""

下一个例子，依次输出a_tuple和a_list中的各个元素：

for index in range(len(a_list)):
    print("index = ", index, ", number in list = ", a_list[index])
"""
index =  0 , number in list =  12
index =  1 , number in list =  3
index =  2 , number in list =  67
index =  3 , number in list =  7
index =  4 , number in list =  82
"""

for index in range(len(a_tuple)):
    print("index = ", index, ", number in tuple = ", a_tuple[index])
"""
index =  0 , number in tuple =  12
index =  1 , number in tuple =  3
index =  2 , number in tuple =  5
index =  3 , number in tuple =  15
index =  4 , number in tuple =  6
"""

list 列表

List 添加

列表是一系列有序的数列，有一系列自带的功能， 例如：

a = [1,2,3,4,1,1,-1]
a.append(0)  # 在a的最后面追加一个0
print(a)
# [1, 2, 3, 4, 1, 1, -1, 0]

在指定的地方添加项：

a = [1,2,3,4,1,1,-1]
a.insert(1,0) # 在位置1处添加0
print(a)
# [1, 0, 2, 3, 4, 1, 1, -1]

List 移除

删除项：

a = [1,2,3,4,1,1,-1]
a.remove(2) # 删除列表中第一个出现的值为2的项
print(a)
# [1, 3, 4, 1, 1, -1]

List 索引

显示特定位：

a = [1,2,3,4,1,1,-1]
print(a[0])  # 显示列表a的第0位的值
# 1

print(a[-1]) # 显示列表a的最末位的值
# -1

print(a[0:3]) # 显示列表a的从第0位 到 第2位(第3位之前) 的所有项的值
# [1, 2, 3]

print(a[5:])  # 显示列表a的第5位及以后的所有项的值
# [1, -1]

print(a[-3:]) # 显示列表a的倒数第3位及以后的所有项的值
# [1, 1, -1]

打印列表中的某个值的索引(index):

a = [1,2,3,4,1,1,-1]
print(a.index(2)) # 显示列表a中第一次出现的值为2的项的索引
# 1

统计列表中某值出现的次数：

a = [4,1,2,3,4,1,1,-1]
print(a.count(-1))
# 1

List 排序

对列表的项排序：

a = [4,1,2,3,4,1,1,-1]
a.sort() # 默认从小到大排序
print(a)
# [-1, 1, 1, 1, 2, 3, 4, 4]

a.sort(reverse=True) # 从大到小排序
print(a)
# [4, 4, 3, 2, 1, 1, 1, -1]

元组的基本操作与列表相同，但元组本身是不可变的，不能随意插入删除元素，但可利用切片的方式对元组进行拷贝，从而间接实现添加删除元素

多维列表

创建二维列表

一个一维的List是线性的List，多维List是一个平面的List：

a = [1,2,3,4,5] # 一行五列

multi_dim_a = [[1,2,3],
               [2,3,4],
               [3,4,5]] # 三行三列

索引

在上面定义的List中进行搜索：

print(a[1])
# 2

print(multi_dim_a[0][1])
# 2

用行数和列数来定位list中的值。这里用的是二维的列表，但可以有更多的维度。

dictionary 字典

创建字典

如果说List是有顺序地输出输入的话，那么字典的存档形式则是无需顺序的， 我们来看一个例子：
在字典中，有key和 value两种元素，每一个key对应一个value, key是名字, value是内容。数字和字符串都可以当做key或者value， 在同一个字典中, 并不需要所有的key或value有相同的形式。 这样说, List可以说是一种key为有序数列的字典。

a_list = [1,2,3,4,5,6,7,8]

d1 = {'apple':1, 'pear':2, 'orange':3}
d2 = {1:'a', 2:'b', 3:'c'}
d3 = {1:'a', 'b':2, 'c':3}

print(d1['apple'])  # 1
print(a_list[0])    # 1

del d1['pear']
print(d1)   # {'orange': 3, 'apple': 1}

d1['b'] = 20
print(d1)   # {'orange': 3, 'b': 20, 'pear': 2, 'apple': 1}

字典存储类型

以上的例子可以对列表中的元素进行增减。在打印出整个列表时，可以发现各个元素并没有按规律打印出来，进一步验证了字典是一个无序的容器。

def func():
    return 0

d4 = {'apple':[1,2,3], 'pear':{1:3, 3:'a'}, 'orange':func}
print(d4['pear'][3])    # a

字典还可以以更多样的形式出现，例如字典的元素可以是一个List，或者再是一个列表，再或者是一个function。索引需要的项目时，只需要正确指定对应的key就可以了。

模块

import 模块

import 的各种方法

import time 指 import time 模块，这个模块可以python自带，也可以是自己安装的，比如以后会用到numpy这些模块,需要自己安装。

import time
print(time.localtime())  #这样就可以print 当地时间了
""""
time.struct_time(tm_year=2016, tm_mon=12, tm_mday=23, tm_hour=14, tm_min=12, tm_sec=48, tm_wday=4, tm_yday=358, tm_isdst=0)
""""

方法二：import time as ____下划线缩写部分可以自己定义，在代码中把time定义成t.设置别名调用更简洁

import time as t
print(t.localtime()) # 需要加t.前缀来引出功能
""""
time.struct_time(tm_year=2016, tm_mon=12, tm_mday=23, tm_hour=14, tm_min=12, tm_sec=48, tm_wday=4, tm_yday=358, tm_isdst=0)
""""

方法三：from time import time,localtime,只import自己想要的功能.

from time import time, localtime
print(localtime())
print(time())
""""
time.struct_time(tm_year=2016, tm_mon=12, tm_mday=23, tm_hour=14, tm_min=41, tm_sec=38, tm_wday=4, tm_yday=358, tm_isdst=0)

1482475298.709855
""""

方法四：from time import * 输入模块的所有功能

from time import *
print(localtime())
""""
time.struct_time(tm_year=2016, tm_mon=12, tm_mday=23, tm_hour=14, tm_min=41, tm_sec=38, tm_wday=4, tm_yday=358, tm_isdst=0)
""""

自建一个模块

这里和视频有点差别，我自己写了另外一个模块，是计算五年复利本息的模块,代码如下：模块写好后保存在默认文件夹：balance.py

d=float(input('Please enter what is your initial balance: \n'))
p=float(input('Please input what is the interest rate (as a number): \n'))
d=float(d+d*(p/100))
year=1
while year<=5:
    d=float(d+d*p/100)
    print('Your new balance after year:',year,'is',d)
    year=year+1
print('your final year is',d)

调用自己的模块
新开一个脚本，import balance

import balance

""""
Please enter what is your initial balance:
50000  # 手动输入我的本金
Please input what is the interest rate (as a number):
2.3  #手动输入我的银行利息
Your new balance after year: 1 is 52326.45
Your new balance after year: 2 is 53529.95834999999
Your new balance after year: 3 is 54761.14739204999
Your new balance after year: 4 is 56020.653782067144
Your new balance after year: 5 is 57309.12881905469
your final year is 57309.12881905469
""""

模块存储路径说明

在Mac系统中，下载的python模块会被存储到外部路径site-packages，同样，我们自己建的模块也可以放到这个路径，最后不会影响到自建模块的调用。

class类、模块、包关系

在这里插入图片描述

• 类： 它将数据和操作进行封装，以便将来的复用。几乎是最小的封装单元了，方便更高的复用
• 模块：在Python可理解为对应于一个文件。在创建了一个脚本文件后，定义了某些函数和变量。你在其他需要这些功能的文件中，导入这模块，就可重用这些函数和变量。
• 包：在创建许许多多模块后，我们可能希望将某些功能相近的文件组织在同一文件夹下，这里就需要运用包的概念了。包对应于文件夹，使用包的方式跟模块也类似，唯一需要注意的是，当文件夹当作包使用时，文件夹需要包含init.py文件，主要是为了避免将文件夹名当作普通的字符串。init.py的内容可以为空，一般用来进行包的某些初始化工作或者设置all值，all是在from package-name import *这语句使用的，全部导出定义过的模块。通常包总是一个目录， 可以是对模块的聚集，包裹在同一个文件夹内。可以使用import导入包，或者from + import来导入包中的部分模块。包目录下为首的一个文件便是 init.py。然后是一些模块文件和子目录，假如子目录中也有 init.py 那么它就是这个包的子包了。

其他

continue & break

True and False 跳出循环

当输入1时，a=False时，会执行接下来的语句后再跳出这个循环。

a=True
while a:
    b= input('type somesthing')
    if b=='1':
        a= False
        print('still in a while')
    else:
        pass #什么都不做跳过
print ('finish run')

''''
type somesthing 2
type somesthing3
type somesthing1
still in a while #会执行下面的语句再跳出
finish run
''''

break

break用法，在循环语句中，使用break, 当符合跳出条件时，会直接结束循环，这是 break和 True False的区别。

while True:
    b= input('type somesthing:')
    if b=='1':
        break
    else:
        pass
    print('still in while')
print ('finish run')

"""
type somesthing:4
still in while
type somesthing:5
still in while
type somesthing:1
finish run
"""

continue

在代码中，满足b=1的条件时，因为使用了continue , python 不会执行 else 后面的代码，而会直接进入下一次循环。

while True:
    b=input('input somesthing:')
    if b=='1':
       continue
    else:
        pass
    print('still in while' )

print ('finish run')
"""
input somesthing:3
still in while
input somesthing:1  # 没有"still in while"。直接进入下一次循环
input somesthing:4
still in while
input somesthing:
"""

总结

break直接跳出循环；
continue跳过后面的，从头开始下一个循环’
flag(True->False)执行完当前一轮循环再退出

try 错误处理

错误处理

输出错误：try:, except ... as ...: 看如下代码

try:
    file=open('eeee.txt','r')  #会报错的代码
except Exception as e:  # 将报错存储在 e 中
    print(e)
"""
[Errno 2] No such file or directory: 'eeee.txt'
"""

处理错误：会使用到循环语句。首先报错：没有这样的文件No such file or directory. 然后决定是否输入y, 输入y以后，系统就会新建一个文件（要用写入的类型），再次运行后，文件中就会写入ssss

try:
    file=open('eeee.txt','r+')
except Exception as e:
    print(e)
    response = input('do you want to create a new file:')
    if response=='y':
        file=open('eeee.txt','w')
    else:
        pass
else:
    file.write('ssss')
    file.close()
"""
[Errno 2] No such file or directory: 'eeee.txt'
do you want to create a new file:y

ssss  #eeee.txt中会写入'ssss'

zip lambda map

zip

• zip()函数的定义
  从参数中的多个迭代器取元素组合成一个新的迭代器；
• 返回：返回一个zip对象，其内部元素为元组；可以转化为列表或元组；
• 传入参数：元组、列表、字典等迭代器。
• 注意：zip(a,b)要求a与b的维数相同，当两者具有相同的行数与列数时，正常组合对应位置元素即可；
  当a与b的行数或列数不同时，取两者结构中最小的行数和列数，依照最小的行数和列数将对应位置的元素进行组合；这时相当于调用itertools.zip_longest(*iterables)函数。

a=[1,2,3]
b=[4,5,6]
ab=zip(a,b)#当zip()函数有两个参数时,zip()函数分别从a和b依次各取出一个元素组成元组，再将依次组成的元组组合成一个新的迭代器
aa=zip(a)#当zip()函数中只有一个参数时,从a中依次取一个元组，组成一个元组。
print(list(ab))
print(list(aa))  #需要加list来可视化这个功能
m = [[1,2,3], [4,5,6], [7,8,9]]
n = [[2,2,2], [3,3,3], [4,4,4]]
p = [[2,2,2], [3,3,3]]
print(list(zip(m,n)))
print(list(zip(m,p)))
"""
[(1, 4), (2, 5), (3, 6)]
[(1,), (2,), (3,)]
[([1, 2, 3], [2, 2, 2]), ([4, 5, 6], [3, 3, 3]), ([7, 8, 9], [4, 4, 4])]
[([1, 2, 3], [2, 2, 2]), ([4, 5, 6], [3, 3, 3])]
"""

zip 中的运算

a=[1,2,3]
b=[4,5,6]
ab=zip(a,b)
print(list(ab))
for i,j in zip(a,b):
     print(i/2,j*2)
"""
0.5 8
1.0 10
1.5 12
"""

zip(*)函数

zip(*)函数是zip()函数的逆过程，将zip对象变成原先组合前的数据。

a = [1,2,3]
b = [4,5,6]
zipped =list(zip(a,b))   # 打包为元组的列表
print(zipped)
aa=zip(*zipped)
print(list(aa)) # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
"""
[(1, 4), (2, 5), (3, 6)]
[(1, 2, 3), (4, 5, 6)]
"""

lambda

• lambda表达式，通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数。
• lambda所表示的匿名函数的内容应该是很简单的，如果复杂的话，干脆就重新定义一个函数了，使用lambda就有点过于执拗了。
• lambda就是用来定义一个匿名函数的，如果还要给他绑定一个名字的话，就会显得有点画蛇添足，通常是直接使用lambda函数。如下所示：

lambda x,y : x+y, 冒号前的x,y为自变量，冒号后x+y为具体运算。

add = lambda x, y : x+y
print(add(1,2))  # 结果为3

1. 应用在函数式编程中
   Python提供了很多函数式编程的特性，如：map、reduce、filter、sorted等这些函数都支持函数作为参数，lambda函数就可以应用在函数式编程中。如下：
   ** 需求：将列表中的元素按照绝对值大小进行升序排列 **

list1 = [3,5,-4,-1,0,-2,-6]
sorted(list1, key=lambda x: abs(x))

当然，也可以如下：

list1 = [3,5,-4,-1,0,-2,-6]
def get_abs(x):
    return abs(x)
sorted(list1,key=get_abs)

只不过这种方式的代码看起来不够Pythonic

2. 应用在闭包中

def get_y(a,b):
     return lambda x:ax+b
y1 = get_y(1,1)
y1(1) # 结果为2

当然，也可以用常规函数实现闭包，如下：

def get_y(a,b):
    def func(x):
        return ax+b
    return func
y1 = get_y(1,1)
y1(1) # 结果为2

只不过这种方式显得有点啰嗦。

map

map接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

def fun(x,y):
    return (x+y)
print(list(map(fun,[1],[2])))
print(list(map(fun,[1,2],[3,4])))
print(list(map(fun,[1,2],[3])))
"""
[3]
[4, 6]
[4]
"""

copy & deepcopy 浅复制 & 深复制

Python中，对象的赋值，拷贝（深/浅拷贝）之间是有差异的，如果使用的时候不注意，就可能产生意外的结果。

id

什么是id？一个对象的id值在CPython解释器里就代表它在内存中的`地址

>>> import copy
>>> a=[1,2,3]
>>> b=a
>>> id(a)
"""
4382960392
"""
>>> id(b)
"""
4382960392
"""
>>> id(a)==id(b)    #附值后，两者的id相同，为true。
True
>>> b[0]=222222  #此时，改变b的第一个值，也会导致a值改变。
>>> print(a,b)
[222222, 2, 3] [222222, 2, 3] #a,b值同时改变

浅拷贝

当使用浅拷贝时，python只是拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。copy只复制父对象，而子对象是共用的，deepcopy完全复制所有的父对象与子对象

>>> import copy
>>> a=[1,2,3]
>>> c=copy.copy(a)  #拷贝了a的外围对象本身,
>>> id(c)
4383658568
>>> print(id(a)==id(c))  #id 改变 为false
False
>>> c[1]=22222   #此时，我去改变c的第二个值时，a不会被改变。
>>> print(a,c)
[1, 2, 3] [1, 22222, 3] #a值不变,c的第二个值变了，这就是copy和‘==’的不同

深拷贝

deepcopy对外围和内部元素都进行了拷贝对象本身，而不是对象的引用。

#copy.copy()
>>> a=[1,2,[3,4]]  #第三个值为列表[3,4],即内部元素
>>> d=copy.copy(a) #浅拷贝a中的[3，4]内部元素的引用，非内部元素对象的本身
>>> id(a)==id(d)
False
>>> id(a[2])==id(d[2])
True
>>> a[2][0]=3333  #改变a中内部原属列表中的第一个值
>>> d             #这时d中的列表元素也会被改变
[1, 2, [3333, 4]]
#copy.deepcopy()
>>> e=copy.deepcopy(a) #e为深拷贝了a
>>> a[2][0]=333 #改变a中内部元素列表第一个的值
>>> e
[1, 2, [3333, 4]] #因为时深拷贝，这时e中内部元素[]列表的值不会因为a中的值改变而改变

threading 什么是多线程

多线程

多线程 Threading 是一种让程序拥有分身效果. 能同时处理多件事情. 一般的程序只能从上到下一行行执行代码, 不过 多线程 (Threading) 就能打破这种限制. 让你的程序鲜活起来.

multiprocessing 什么是多进程

多进程

我们在多线程 (Threading) 里提到过, 它是有劣势的, GIL 让它没能更有效率的处理一些分摊的任务. 而现在的电脑大部分配备了多核处理器, 多进程 Multiprocessing 能让电脑更有效率的分配任务给每一个处理器, 这种做法解决了多线程的弊端. 也能很好的提升效率.

什么是 tkinter 窗口

窗口视窗

Tkinter 是使用 python 进行窗口视窗设计的模块. 简单的构造, 多平台, 多系统的兼容性, 能让它成为让你快速入门定制窗口文件的好助手. 它在 python 窗口视窗模块中是一款简单型的. 所以用来入门, 熟悉 窗口视窗的使用, 非常有必要.

pickle 保存数据

pickle 保存

pickle 是一个 python 中, 压缩/保存/提取 文件的模块. 最一般的使用方式非常简单. 比如下面就是压缩并保存一个字典的方式. 字典和列表都是能被保存的.

import pickle
a_dict = {'da': 111, 2: [23,1,4], '23': {1:2,'d':'sad'}}
# pickle a variable to a file
file = open('pickle_example.pickle', 'wb')
pickle.dump(a_dict, file)
file.close()

wb 是以写的形式打开 ‘pickle_example.pickle’ 这个文件, 然后 pickle.dump 你要保存的东西去这个打开的 file. 最后关闭 file 你就会发现你的文件目录里多了一个 ‘pickle_example.pickle’ 文件, 这就是那个字典了.

pickle 提取

提取的时候相对简单点, 同样我们以读的形式打开那个文件, 然后 load 进一个 python 的变量.

# reload a file to a variable 
#使用with避免忘记关file
with open('pickle_example.pickle', 'rb') as file:
    a_dict1 =pickle.load(file)
print(a_dict1)

set 找不同

set 基本

Set 最主要的功能就是寻找一个句子或者一个 list 当中不同的元素.

char_list = ['a', 'b', 'c', 'c', 'd', 'd', 'd']
sentence = 'Welcome Back to This Tutorial'
print(set(char_list))
# {'b', 'd', 'a', 'c'}
print(set(sentence))
# {'l', 'm', 'a', 'c', 't', 'r', 's', ' ', 'o', 'W', 'T', 'B', 'i', 'e', 'u', 'h', 'k'}
print(set(char_list+ list(sentence)))
# {'l', 'm', 'a', 'c', 't', 'r', 's', ' ', 'd', 'o', 'W', 'T', 'B', 'i', 'e', 'k', 'h', 'u', 'b'}

添加元素

定义好一个 set 之后我们还可以对其添加需要的元素, 使用 add 就能添加某个元素. 但是不是每一个东西都能添加, 比如一个列表.原本存在的元素不会被添加。

char_list = ['a', 'b', 'c', 'c', 'd', 'd', 'd']
unique_char = set(char_list)
print(type(unique_char))
unique_char.add('x')
#unique_char.add(['y', 'z']) this is wrong
print(type(unique_char))
print(char_list)
print(unique_char)
char_list.append('x')#list用append，set用add
print(char_list)
"""
<class 'set'>
<class 'set'>
['a', 'b', 'c', 'c', 'd', 'd', 'd']
{'x', 'b', 'a', 'd', 'c'}
['a', 'b', 'c', 'c', 'd', 'd', 'd', 'x']
"""

清除元素或 set

清除一个元素可以用 remove或者 discard, 而清除全部可以用 clear.

char_list = ['a', 'b', 'c', 'c', 'd', 'd', 'd']
unique_char = set(char_list)
# unique_char.remove('x') 移除不存在的值会报错
print(unique_char.remove('a')) #直接打印返回的都是none，需要重新print这个set才能看到剩余值
print(unique_char)

unique_char.discard('x')#不报错，返回原有数据
print(unique_char)
unique_char.discard('d')
print(unique_char)
print(unique_char.discard('c'))#直接打印同样返回none

unique_char.clear()#清除所有
print(unique_char)
"""
None
{'c', 'b', 'd'}
{'c', 'b', 'd'}
{'c', 'b'}
None
set()
"""

筛选操作 /对比 （交集&差集）

我们还能进行一些筛选操作, 比如对比另一个东西, 看看原来的 set 里有没有和他不同的 (difference). 或者对比另一个东西, 看看 set 里有没有相同的 (intersection).

char_list = ['a', 'b', 'c', 'c', 'd', 'd', 'd']
A= set(char_list)
print(A)
B={'a', 'e', 'i'}
print(B)
print(A.difference(B))#A-B
print(A.intersection(B))#A∩B
"""
{'b', 'c', 'd', 'a'}
{'e', 'i', 'a'}
{'b', 'c', 'd'}
{'a'}
"""