python怎么复习_python 复习与总结

概述

这篇文章，我花了一周的时间将代码和图片整数上来，这篇文章被分成了两个部分，一个是我在数据学习社区里面写的一些基本的代码，我将图片贴了上来，内容和猴子老师的差不多；第二部分是我自己看的官方文档的部分，因为我之前没有看过官方的文档，回过头来发现必看的内容我居然漏了。官网的东西是最新的，最正宗的，看书的时候发现python的书太多了，但是很多书的代码已经过时了。尤其是一些第三方库，python2和python3不相同确实是个大坑。总之对官网内容的学习算是查漏补缺吧，Keep learning。

第一部分

代码贴图

这里要注意集合的方法，update可以一次添加多个元素，但是add方法则只能添加一个元素进去，要注意的是update接收列表，这样才能传入多个元素,如果不传入列表类型的话，会将每一个字符分开。

people = {"爸爸","妈妈","孩子"}

people.add("爷爷","奶奶")#这样会报错，因为add方法直接一个元素

people.update([,"爷爷","奶奶"])#这样就没问题

people.update(,"爷爷","奶奶")#这样会出错，因为输出的会是

{"爷"，"奶"}

#discard方法不能接收列表作为参数因此一次也只能删除一个元素

第二部分

交互模式下的一些技巧

’-‘ 活用下划线，在交互模式中，下划线是一个变量，可以存贮上一次计算出的结果。

#下划线作为变量的例子

a = 10

b = 20

a + b

30

c = 40

c + _

70

这里要注意下划线变量是一个只读变量，不能给他赋值。

字符串

在python3中已经不能用反斜杠去换行了，如果字符串很长的话，需要可以用下面的形式去将长字符串连在一起。

my_string = "I love to eat humbuggers " " and also I like drinking Cocal"

print(my_string)

I love to eat humbuggers and also I like drinking Cocal

这种形式只能用在两段字符串之间，不能用于变量或者是括号。

用’+’ 去连接变量和字符穿，比如

str = ‘py’

Str + ’thon’

‘python’

Python字符串输出的方法，记住一个语法，加上自动填充符号的语法。在python中使用format方法格式化输出是最好最强大的。

print(“{:*^20}”.format(“hanxiao”)) = print(“hanxiao”.center(20, ‘*’))

#字符串打印的一个技巧右对齐

"""这种打印的方法等同与使用函数center、ljust，rjust"""

print("characters".center(20,'*'))

>>>**********characters**********

print("characters".ljust(20, '*'))

>>>character********************

print("characters".rjust(20, '*'))

>>>********************characters

一点小小的体会总结：写到这里python的坑挺大的，其实之前一直有这样的体会。但说不清楚。str这个函数在C里面没有，在C++里面是作为一个类存在的。

因为之前写C或者C++的时候习惯用str去命名字符串。用C/C++写的代码感觉是确实要更健壮一些，python的确十分适合快速开发，但是python其实并不简单，写完代码没有编译过程直接运行，有什么debug起来确实要麻烦一些，C语言简单，我很喜欢，但是C++确实强大了不少，我会继续保持C++和数据结构与算法的学习。

关于下标的问题

在python中下标 -0 等于0，别忘了反向遍历用-1.

如果使用一个特别大的下标(超出了字符串本身的长度很多)那么会导致错误发生。，但是用切片可以避免切片出现。

Word = ‘python’

Word [42]会报错，

但是word[4:42] 会显示’on’，

如果是word[42:] 会显示空白字符串

由于python的字符串是无法改变的，因此通过给下标赋值，获取新的字符串是会报错的，

比如：

Word [0] = ‘J’ 这样就会报错

要改变的话只能新创建一个字符串

‘J’ + word[1:]

"""用python写Fibonacci数列的最简单办法：这个循环获取费氏数列中小于10的数"""

a,b = 0 ,1

While a < 10:

Print(a)

a,b=b,a+b

字符串中‘*’，可以看作是复制，而不是数字的乘以。

Control Flow 控制流

这个没啥好说的了格式记住就可以了

生成器(generator)，别忘了生成器和函数很像，只是在最后的时候用yield返回。最常用的range();函数enumerate()可以返回一个迭代对象的索引下标和值，

List1 = [‘yiyang’, ‘pangbao’, ‘bama’, ‘wo’]

#enumerate的用法

for inede, name in enumerate(list1):

print(index, name)

else语句

else 语句在循环中的使用很有意思

for n in range(2, 10):

for x in range(2,n):

If n % x == 0:

print(n,’equals’, x, ‘*’, n//x)

break

else:

#loop fell through without finding a factor

print(n, ‘is a prime number’)

瞎捣鼓了一个九九乘法表,代码如下

for n in range(1,10):

for m in range(1,10):

print(n,’*’,m,’=‘,n*m,end=‘\t')

print(‘\n')

输出结果：

有个常用的pass站位符，写函数常会用到，了解一下，就可以了。

复习到这里，我觉得开始写一下三种基本排序方法很有必要了。

冒泡排序：

length = len(collection) 这里的长度等于是列表元素的个数

list1 = [1,2,3,4,5]

len(list1) = 5

for I in range(length) #range = 0-5

#导入

from __future__ import print_function

#函数定义

def bubble_sort(collection):

“””Bubble sort practice”””

length = len(collection)

for I in range(length-1):

swapped =False

for j in range(length-1-i):

If collection[j] > collection[j+1]:

swapped = True

collection[j],collection[j+1] = collection[j+1], collection[j]

return collection

#入口

If __name__ == ‘__main__’:

try:

raw_input #python 2

except:

raw_input = input

user_input = input(“Enter numbers separated by comma:”).strip()

unsorted = [int(number) for number in user_input.split(‘,’)]

print(*bubble_sort(unsorted))

选择排序，选择排序遇到了问题，我没有搞懂，花了一些时间，写出对程序始终无法正确排序。选择排序一般先到最小值或最大值，这一步非常简单，但是比较一下找最大值和最小那个更简单的话，我觉得找最小值更简单一些。我试着用找最小值的方法写了一下选择排序。无法排出正确的大小，换了找最大值的方法也不行。

过了一天，我重新开始写选择排序了，这次比上回好一些，但是得出的排序顺序和我想的不一样，我需要的是升序，而我写出来的代码是降序排序，代码如下：

def selection_sort(numbers):

for i in range(0, len(numbers)):#第一层控制最大值的交换

maxi = i#从第一个数开始找最大值

for j in range(i+1, len(numbers)):#第二层负责找大最大值

if numbers[maxi] < numbers[j]:

maxi = j#找到最大值的下标

number[maxi], numbers[i] = numbers[i], numbers[maxi]#交换最大值

return number

if __name__ == '__main__':

user_input = input("Enter numbers: ").strip

unsorted = [int(number) for number in user_input.split(',')]

print(selection_sort(unsorted))

上面的代码写出来之后，找到了一点感觉，趁热打铁写了出来：

def select_sort_ascending(numbers):

for i in range(len(numbers)-1, 0,-1):

maxi = 0

for j in range(1, i+1):

if numbers[maxi] < numbers[j]:

maxi = j

numbers[maxi], numbers[i] = numbers[i], numbers[maxi]

return numbers

if __name__ == '__main__':

user_input = input("Enter numbers: ").strip()

unsorted = [int(number) for number in user_input.split(',')]

print(selection_sort(unsorted))

这下终于对了。

插入排序：

插入排序，简单的来说就像是手里拿着扑克，将数字一个个插入进来一样。

def insertion_sort(numbers):

length = len(numbers)

for i in range(1, length):

while i > 0 and numbers[i-1] > numbers[i]:

numbers[i], numbers[i-1] = numbers[i-1], numbers[i]

return numbers

if __name == "__main__":

user_input = input("Enter numbers to sort separated by comma: ").strip()

unsorted = [int(number) for . number in user_input.split(',')]

print(insertion_sort(unsorted))

插入排序可以很好的工作，得到的结果没问题。

接下来需要重新看看数据结构的知识了。

函数递归

受上面fibonacci数列的影响，我又折腾了一下fibonacci数列。这里我写了一个fibonacci数列，用来做递归演示，输入一个数字，这个数字表示fibonacci数列中的第N项，函数可以返回fibonacci数列上的这个数。

def fibonacci(position):

“””

Enter the Nth number to get the number in the fibonacci series

“””

if position == 0:

return 0

if position == 1:

return 1

else:

return fibonacci(position-1) + fibonacci(position-2)

If __name__ == ‘__mian__’:

user_input = input(“Enter a number to get the Nth number in fibonacci series:”)

position = int(user_input)

number = fibonacci(position)

print(number)

在函数中return 可以以元祖的形式返回多个值，我之前将上面的函数第一个If判断后的return返回值改成0，1，得到了这样一个元祖。

另外一个函数遇到了一个小问题，不知道为什么用脚本运行出来之后最后输出一个None。

def fibonacci_numbers(number):

"""Enter a number to get numbers are smaller than it in the fibonacci squences"""

If number == 0:

return 0

else:

a, b = 0, 1

while a < number:

print(a)

a, b = b, a + b

If __name__ == ‘__main__’:

user_input = int(input(“Enter a number to get the numbers are smaller than it in the fibonacci sequence: “))

print(fibonacci_numbners)

输出为：

接下来稍稍改进一下，用列表去存储生成的数字。

def fibonacci_list(number):

“””

Using list to store the numbers in fibonacci sequence

“””

If number == 0:

return []

else:

a, b = 0 ,1

result = []

while a < number:

result.append(a)

return result

If __name__ == ‘__main__’:

user_input == int(input(“Enter a number to get the numbers are smaller than it in fibonacci sequence:”))

print(fibonacci(user_input))

这样得到是一个不包含None的列表。

函数参数的警告：

函数的默认参数只能被评估一次，因此它具有易变形，尤其是像列表，字典，实例或者是大部分的类。例子如下：

def f(a , L = []):

L.append(a)

return L

f(10) 打印出来的话>>>[10]

f(20) ——>>>[10,20]

f30) ———>>>[10,20,30]

未来避免类似的情况可以这样写：

def f(a, L=None):

if L == None:

L = []

L.append(a)

return L

>>>f(10)

[10]

>>>f[20]

[20]

>>>f(30)

[30]

关键字参数

关键字参数的kwarg要注意的几个地方：

第一、不能缺失必要的值

第二、关键字参数要在非关键词参数后

第三、不能重复的赋值

第四、不能输入错误的关键字

以上代码源于我想吃康师傅香辣牛肉面而不得，愤懑而书，纽约为什么每一家卖康师傅的超市了？

一个*星号的协议参数要放在关键字参数的前面。关键字参数有两个星号**。协议参数写作*args，关键字参数再来记一下**kwargs。

这里遇到一个比较好玩的函数，两行代码，足够显示python的强大了。

def concat(*args, sep= “/“):

return sep.join(args)

join这个函数很神奇，是一个字符串类下的方法。

Name = “xiao"

Sep = ‘/'

Sep.join(name)

会得到"x/i/a/o/"

在函数传参数的时候，如果遇到了参数没法分开的情况，可以用解包的办法传入参数：

list(range(3, 6)) ——> [3,4,5]

Args = [3, 5]

List(range(*args))—->可以得到一样的结果[3,4,5]—>通过一个星号，* 家名字的方法可以作为函数的参数传入到函数中

同样的办法，字典可以用这样的方法进行解包，因为字典是mapping类型的容器，那么将字典用两个**星号加名字传入函数中可以获取到相关的信息。

Lambda匿名函数

Lambda anonymous function匿名函数：lambda 变量：表达式

Lambda函数也可以在包含的范围内

文档字符串的写法

首先是第一行一定要简短，要包含这个对象的目的。它不应该精确的陈述对象的名字或者类型，第一行要用大写字母开头，逗号结尾。如果文档字符串很多的话呢，第二行应该是空格。

输出函数的文档用方法.__doc__

函数注释---> 选择项

python代码风格：四个空格，而不是用tab键

每行不要超过79个字符

用空行去分割函数、类，还有函数中更大的代码模块

尽可能将注释放到单独的一行

使用文档字符串

使用空格键在运算符两边，在逗号之后

用大写字母开始命名类，各个词之间都要大写，用下划线分割函数和方法，始终使用self方法作为第一个方法协议

使用python默认的编码

不要使用非ASCII字符

数据结构

列表

列表的方法

list.append()#在最后追加一个元素

list.extend() #连接两个列表

list1 = [1,2,3,4]

list2 = [5,6,7,8]

list1.extend(list2)

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

list.insert(index, value) #->在指定位置插入一个元素

list.remove(value) #删除一个值

list.pop()#默认弹出最后一个元素

list.clear()#清除列表

list.index(value, index)#获取某一值的位置

list.count(value)#值在列表中出现的次数

list.reverse()#反转列表

list.sort()#**排序，会改变列表本身顺序，而内建函数sorted()则不会改变列表本身

list.copy()#返回一个文本，而不是本身

list1 = [1,2,3,4]

list2 = list1.copy()

list2.append(5)

>>print(list2)

[1,2,3,4,5]

>>>print(list1)

[1,2,3,4]

像堆栈一样使用列表

一点点数据结构复习

堆栈，stacks--->Last in, First out.

队列，queues-->First in, First out.

在python中列表非常强大，可以将列表当作stacks使用，如list.append()可以插入一个元素到最后的位置，然后用list.pop()将其弹出并获得。也可以将列表当作queues队列使用，这个基本的数据结构在collection 这个库里面，这是一个python自带的一个非常重要有用的库，可以先学习。如：

from collections import deque

queue = [“ZhangSan”, “LiSi”, “WangWu”]

queue.append(“SongLiu”)

queue.append(“LiuQi”)

queue.popleft()

>>>’ZhangSan’

queue.popleft()

>>>’LiSi’

queue

>>>[‘WangWu’, ’SongLiu’, ‘LiuQi']

python列表推导式

列表推导式非常的pythonic，非常的方便和强大，除了列表推导式外，也有元祖推导式，字典推导式，和集合推导式，但是集合推导式得到的是一个生成器generator。关于推导式，可以在后面再复习一下。

列表推导式可以非常简洁的创建一个列表，常见的用法是把某种操作应用于序列或可迭代对象的每个元素上，然后使用其结果来创建列表。通常我们创建一个列表的方法是：

result = []

for I in range(10):

result.append(I**2)

result

>>>[0,1,4,9,16,25,36,49,64,81]

列表生产式的写法：

result = [i**2 for i in range(10)]

列表推导式中for语句后面也可以接for或者if语句，例如：

[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]

[(1,3), (1,4), (2,3), (2,1), (2,4), (3,1), (3,4)]

#上面式子等价于

combs = []

for x in [1,2,3]:

for y in [3,1,4]:

if x != y:

combs.append((x, y))

>>>combs

[(1,3), (1,4), (2,3), (2,1), (2,4), (3,1), (3,4)]

更多关于列表推导式的内容：

>>>vec = [-4, -2, 0, 2, 4]

>>>#create a new list with the values doubleed

>>>[x*2 for x in vec]

[-8, -4, 0, 4, 8]

>>>[x for x in vec if x>=0]

[0, 2, 4]

>>>[abs(x) for x in vec]

[4, 2, 0, 2, 4]

>>>#call a method on each element

>>>fresh fruit = [' banana', ' loganberry', 'passion fruit ']

>>>[weapon.strip() for weapon in freshfruit]

['banana', 'loganberry', 'passion fruit']

>>>#create a list of 2-tuples like (number, square)

>>>[(x, x**2) for x in range(6)]

[(0,0), (1,1), (2, 4), (3, 9), (4, 16), (5, 25)]

>>>#the tuple must be parenthesized, otherwise an error is raised

>>>#元祖必须要加上括号才行，不然就会报错

>>>#flatten a list using a listcomp with two 'for'

>>>#将一个嵌套的列表合为一个列表需要用到多个for

>>>vec = [[1,2,3], [4,5,6], [7,8,9]]

>>>[num for elem in ver for num in elem]

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

#列表推导式可以使用复杂的表达式和嵌套函数

>>>from math import pi

>>>[str(round(pi, i)) for I in range(1,6)]

['3.1', '3.14', '3.142', '3.1416', '3.14159']

#将参数pi和i传入到函数round中，第一个参数为值，第二个参数为小数点后面的位数，

#随着循环的迭代，逐渐增加小数点后面的位数，然后将浮点型数据转化成字符串类型。

嵌套的推导式

列表推导式中最先的表达式可以是任意形式的表达式，甚至包括了另一个列表推导式。

下面的例子非常好，矩阵转置：

>>>matrix = [

[1,2,3,4],

[5,6,7,8],

[9,10,11,12],

]

#下面的列表推导式将会转置行和列

>>>[[raw[i] for row in matrix] for i in range(4)]

[[1, 5, 9], [2, 6, 10], [9, 10, 11, 12]] #------->numpy里面有.T 可以直接转置一个矩阵

在实际应用中，我们我们应该会更喜欢用内置的函数去组成复杂的流程语句。zip()函数可以很好的处理这种情况。zip函数将数据打包在一起。比如：

names = [“ZhangSan”, “LiSi”, “WangWu”]

Indexed = [‘1’, ‘2’. ‘3’]

list(zip(names, indexed))

>>>[('zhangsan', '1'), ('lisi', '2'), ('wangwu', '3’)]

#或者是

dict(zip(names, indexes))

>>>{'zhangsan': '1', 'lisi': '2', 'wangwu': '3’}

这样可以轻松的创建一个字典

这里再次回顾一下解包参数列表，如果一个函数需要超过一个参数的话，比如range函数需要单独的参数start和stop参数。如果要传入的参数不能单独使用的话，运用’*’星号运算符编写函数调用以从列表或者元祖种捷报解包参数。

例子：

list(range(2，6))

[3,4,5]

args = [3,6]

List(range(*args))

[3,4,5]

我觉得官方文件的这个例子不是很直观，我的理解可能更准确，用zip()函数作为例子：

list_to_dict=[["ZhangSan", "1"], ["LiSi", "2"], ["WangWu", "3"], ["ZhaoLiu", '4’]]

list(zip(*list_to_dict))

[('ZhangSan', 'LiSi', 'WangWu', 'ZhaoLiu'), ('1', '2', '3', '4’)]

我本来想用这个函数像上面一样去创建一个字典，可是不知道解包参数这里不行。只能生成列表。后续会回头看看这个用法。

Del语句

#del 语句可以按照给出的索引值删除元素，例如：

a = [1,2,3,4,5]

del a[0]

>>>a

[2,3,4,5]

del a[2:4] #删除2-3位的元素

>>>[2,5]

del a[:] #or del a

>>>a

[]

元祖

记住一点就可以了，元祖就是无法改变的列表，和字符串一样的。然后就是元祖的解包

t = (10,20,30)

a, b, c = t

Print(a, b, c)

>>>10 20 30

集合

顾名思义，就是集合(set)，集合类型提供了一个无序的不重复元素的集。同样用花括号{}去表示，基本的用法是测试和消除重复的元素。集合对象也提供了数学运算比如并集，交集，差集和对称差分。利用set()创造一个集合。创建一个空的集合只能用set()而不能用{}.花括号是用来创建空字典的。

basket = {‘apple’, ‘orange’, ‘apple’, ‘pear’, ‘organge’, ‘banana’}

Print(basket)

>>>{‘orange’,’banana’, ‘pear’, ‘apple’}

‘orange’ in basket

>>> True

‘crabgrass’ in basket

>>>False

#完成集合运算在两个单独词语中

a = set(‘abracadabra’)

b = set(‘alacazam’)

>>>a

{‘a’, ’r’, ’b’, ’c’, ’d’}

a - b #字母在a但不在b中

>>>{‘r’, ‘d’, ‘b’}

a | b #字母在a或在b中或者两者都在

>>>{‘a’, ‘c’, ‘r’, ‘d’, ‘b’, ‘m’, ‘z’, ‘l’}

a & b #字母即在a又在b

>>>{‘a’, ‘c’}

a ^ b #字母在a或在b但不同时在两者中

>>>{‘r’, ‘d’, ‘b’, ‘m’, ‘z’, ‘l’}

#集合推导式：

a = {x for x in ‘abracadabra’ if x not in ‘abc’}

>>>a

{‘r’, ‘d’}

字典

映射类型字典。字典的键为不能更改的类型，字符串、整数、元祖经常作为键key，元祖如果只包含字符串、数字或者元祖的话。不管是直接或者非直接的使用可改变类型，都不能作为key使用。可以看作是一个键值对。用list()函数可以将字典的key都列出来。利用内置函数sorted()对字典排序，利用逻辑运算符in查看key是否在字典中。

循环技术

遍历一个字典的key和值时使用.items()

利用函数enumerate在for循环中获取索引和值

利用zip将两个或两个以上的序列同时遍历：

questions = [’name’, ‘quest’, ‘favorite color’]

Answers = [‘lancelot’, ’the holy grail’, ‘blue’]

for q,a in zip(questions, answers):

print(‘What is your {0}? It is {1}.’.format(q,a))

What is your name? It is lancelot.

What is your quest? It is the holy grail.

What is your favorite color? It is blue.

#遍历反向输出：for i in reverse(range(1,10,2)):

9

7

5

3

1

#利用sorted遍历一个序列，可以返回一个新的排序的列表，同时保持原来的数据不变

basket = [‘apple’, ‘orange’, ‘apple’, ‘pear’, ‘orange’, ‘banana’]

for f in sorted(set(basket)):

print(f)

apple

banana

orange

pear

#有时候试图在遍历的时候改变一个列表，那么最好重新创建一个新列表代替它。

Import math

Raw_data = [56.2, float(’Nan’), 51.7, 55.3, 52.5, float(’Nan’), 47.8]

filtered_data = []

For value in raw_data:

If not math.isnan(value):

Filtered_data.append(value)

Filtered_data

>>>[56.2, 51.7, 55.3, 52.5, 47.8]

#Is，is not 是比较运算符，它们比较一个对象是否是同一个对象，这个只有关乎于可变对象，比如列表。

list1 = [1,2,3,4]

>>> list2 = [5,6,7,8]

>>> list1 is list2

False

>>> list3 = list1

>>> list1 is list3

True

这里要注意is 和 == 的区别：is它比较多是一个对象是否是同一个对象。

序列的比较——>短序列小于长序列。

模块

sys模块

Sys.ps1和sys.ps2定义用作辅助提示的字符串

import sys

sys.ps1

'>>>’

Sys.ps2

‘…'

Sys.ps1 = ‘C>’

C> print(‘Yuck!’)

Yuck!

C>

这两个变量只有在交互模式下才能被定义

import sys

sys.path 用于确定解释器模块和搜索路径

dir()用于查找模块定义的名称，它返回一个排序过的字符串列表

我在写import dir()函数代码的时候有一个小发现，我之前写了一个才数字程序名字叫py.py

我导入了程序得到了以下的结果：

import py,sys

Enter your number to start the game: 1

Your number is too small.

You have 4 opertunities.

Enter your number to start the game: 50

Your number is too small.

You have 3 opertunities.

Enter your number to start the game: 2

Your number is too small.

You have 2 opertunities.

Enter your number to start the game: 3

Your number is too small.

You have 1 opertunities.

Enter your number to start the game: 4

Your number is too small.

You have 0 opertunities.

You don't have more opertunities!

>>> import py

程序自动启动了，但是只有在和sys模块同时导入的时候才行。

后来我用其他的程序再试了几下，都可以在交互模式下启动，所以同时导入sys和其他python程序可以直接在交互模式下启动程序。

Dir()函数

包

必须要有__init__.py 才能让python将包含该文件的目录当作包。

以下是来自官方的一段话：

“请记住，使用 from package import specific_submodule 没有任何问题！ 实际上，除非导入的模块需要使用来自不同包的同名子模块，否则这是推荐的表示法。”

格式化输出

f/F“{variable}”

.format()

str()和 repr()可以快速的显示变量已进行调试。

格式化串文字：

import math

print(f’The value of pi is approximately {math.pi:.3f}.’)

The value of pi is approximately 3.142.

在’：’后面传递一个整数可以让该字段成为最小字符宽度。这在使列对齐时很有用：

table = {’Sjoerd’: 4127, ‘jack’: 4098, ‘Dcab’: 7678}

For name, phone in table.items():

Print(f”{name:10}==>{phone:10d}”)

Sjoerd ==> 4127

Jack ==> 4098

Dcab ==> 7678

>>> name = 'Xiao Han'

>>> f"{name:20}", '$'*10,"{name:10}"

('Xiao Han ', '$$$$$$$$$$', '{name:10}')

>>>

print(f"{name:20}", f"$*10",f"{numbr:10}")

Xiao Han $*10 917

如果有一个长字符串最好用名称来引用变量进行格式化。

可以通过传统字典和使用[ ] 访问键来完成。

table= {’Sjoerd’: 4127, ‘Jack’:4098, ‘Dcab’: 8637678}

print(‘Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d};’Dcab: {0[Dcab]:d}’.format(table))

#0代表的是table这一个标量，因为一直是这一个变量在格式化输出，用字典中的键去访问值，d表示整数。

简单一点的做法是用’**’两个星号作为关键字参数传递：

print(‘Jack:{Jack:d}; Sjoerd: {Sjoerd:d};Dcab:{Dcab:d}’.format(**table))

记住一点“：“后面跟的是距离前面的距离,符号在方向的后面：

>>> for x in range(1,11):

... print('{0:#<5d}{1:*^10d}{2:@>10d}'.format(x,x*x,x*x*x))

...

1####****1*****@@@@@@@@@1

2####****4*****@@@@@@@@@8

3####****9*****@@@@@@@@27

4####****16****@@@@@@@@64

5####****25****@@@@@@@125

6####****36****@@@@@@@216

7####****49****@@@@@@@343

8####****64****@@@@@@@512

9####****81****@@@@@@@729

10###***100****@@@@@@1000

> 表示在左边

字符串方法.zfill()可以在数字字符串的左边填充零，它能识别正负号：

>>>’12’.zfill(5)

00012’

>>>’-3.14’.zfill(7)

‘-003.14’

>>>’3.14159265359’.zfill(5)

‘3.14159265359’

#我的测试

>>> '19'.zfill(10)

'0000000019'

>>> '-19.08'.zfill(10)

'-000019.08'

>>> '19.08'.zfill(10)

'0000019.08'

>>> '19.08'.zfill(11)

'00000019.08'

>>> '19.08'.zfill(12)

‘000000019.08'

读写文件

也没啥好说的

最好的办法是with open，读写的几个模式r 读，r+ 读写，w写，a追加。

如果不用with 要记住关闭文件用close()

文件的方法

read()

readline()

Write()

tell() #返回一个整数，给出文件对象在文件中的位置。

seek(offset，from__what) #第一个是位置参数，起点有第二个参数from__what参数指定。0表示从头开始，1表示从当前位置开始，2表示从末尾作为参考点。

>>>f = open(‘workfile’,’rb+’)

>>>f.write(b’0123456789abcdef’)

16

>>>f.seek(5) #Go to the 6th byte in the file

5

>>>f.seek(1)

b’5’

>>>f.seek(-3, 2) #Go to the 3rd byte before the end

13

>>>f.read(1)

b'd'

使用json保存结构化数据

import json

json.dumps([1, ’simple’,’list’])

‘[1, “simple”,”list”]'

#dumps()函数的另一个变体叫做dump()，它只将对象序列化为text file。因此，如果f是一个text file对象，我们可以#这样做：

json.dump(x, f)

#要再次解码对象，如果f是一个打开的以供阅读的text file对象：

x = json.load(f)

异常

如果try语句发生了异常，那么则跳过该子句中剩下的部分。然后，如果异常的类型和excpt关键字后的异常匹配，则执行except子句，然后继续执行try后面的代码。

如果发生的异常和except子句中指定的异常行为不匹配，则将其传递到外部的try语句中，如果没有找到处理程序，则它是一个未处理异常，执行将停止并显示如上所示的消息。

except(RuntimeError, TypeError, NameError):

Pass

try,except,else

else 子句可以避免try except接收到的异常，因此要比在try子句中添加代码要好一些。

抛出异常

raise 允许程序员强制发生指定的异常。例如：

raise NameError(‘Hi there’)

Traceback (most recent call last):

File "", line 1, in

NameError: HiThere

raise 唯一的参数就是要抛出的异常，这个参数必须是一个异常实例或者是一个异常类.

try的另一个字句是finally，它将无论如何都会执行，无论有没有发生异常，即便是在try语句中通过break，continue，return这些语句离开finally也会在离开前被执行。

def divide(x, y):

try:

result = x/y

except ZeroDivisionError:

print("Division by zero!")

else:

print("result is", result)

finally:

print("executing finally clause")

>>> divide(2, 1)

result is 2.0

executing finally clause

>>> divide(2, 0)

division by zero!

executing finally clause

>>> divide("2", "1")

executing finally clause

Traceback (most recent call last):

File "", line 1, in

File "", line 3, in divide

TypeError: unsupported operand type(s) for /: 'str' and 'str'

类

del 可以删除类里面的属性，例如：

del moname.the_answer #删除moname模块中的the_answer 属性

注意一下命名空间和作用域。

def scope_test():#定义函数

def do_local():#嵌套函数

spam = "local spam"#函数里面定义给变量spam赋值，注意此时的作用域

def do_nolocal():#嵌套函数

nonlocal spam #嵌套函数内部定义变量spam的作用域

spam = "nonlocal spam"# 定义变量spam

def do_global():#嵌套函数

global spam #在嵌套函数内部定义变量spam作用域

spam = "global spam"#定义变量spam

"""整个函数执行的过程||V||V||V||V是自上而下的"""

spam = "test spam"

do_local()

print("After local assignment:", spam)

do_nonlocal()

print("After nonlocal assignment:",spam)

do_global()

print("After global assignment:",spam)

scope_test()

print("In global scope:", spam)

以上的代码执行之后会得到

After local assignment: test spam

After nonlocal assignment: nonlocal spam

After global assignment: nonlocal spam

In global scope: global spam

l

class MyClass:

"""A simple example class"""

i = 12345

def f(self):

return "Hello, world"

这里注意一下，第一类的命名要用大写字母开头，驼峰命名法，MyClass.i 和MyClass.f都是类的属性，所以也同样可以通过MyClass.i 去给属性赋新的值。

类的_init__方法

x.counter = 1

while x.count < 10:

x.count = x.counter * 2

print(x.counter)

def x.counter

以上代码可以简单的改一下成为pow方法。

方法的第一个参数被命名为self，这是一个约定。

关于类的内容我会单独的写一些。

collections 包---基本的数据结构

下面记录一点关于collections库的内容：

线性结构queue，stack

FIFO，LIFO

# Stack()创建一个新的空盏，不需要参数，返回一个空的盏

# push()添加一个元素在盏顶，它需要添加的元素，没有返回值

#pop()移除盏顶的值，不需要参数，返回盏顶的值，然后整个盏被修改

#peek()返回盏顶的值，但不移除，不需要参数，不会修改盏

#isEmpty()测试是否为空盏

#size()返回盏内元素的个数，不需要参数，返回一个整数。

简单总结一下

我学习python已经又一段时间了，也已经读过了很多的python相关书籍，中文的英文的，在写完这个文章之后发现，对类的学习还需要加强，面向对象的四个特点，继承(inheritance)，多态(polymorphsim)，封装(encapsulation)、抽象(abstraction)，还需要再进一步的加深对类的学习，和对面向对象编程的理解。另外，要再继续再学一学python的标准库、第三方库，还有算法的学习。

数据分析要求的python编程能力没有那么的强，不过我在学习数据分析的时候最开始拿着书，很多东西并不懂，所以还是要从最基本的东西开始学习，懂一些套路，懂一些基本的流程，幸好经过了初级数据分析师的学习知道了很多知识。