python学习笔记
Python 手册(https://docs.python.org/3/)的使用方法：
通过type()函数找到变量所属的类型，然后在官方文档中进行搜索。
通过type()函数找到变量所属的类型，然后在官方文档中进行搜索。
print函数
python中的print函数与C语言中printf函数比较相似，但是有以下几点区别：
- python语句的结尾不需要分号，而且如果添加了分号的话会出现语法错误
- print函数自动换行，所以不需要像C语言中的printf函数那样在结尾手动换行，但是仍然可以在print函数中使用转义字符。如果不需要它自动换行，可以使用end=“ ”的方式让它以空格分割
- python的print函数输出变量的格式和C语言中的printf函数不同，且控制变量位数的语句也不相同：
//C语言 #include<stdio.h> int main(int argc, char const *argv[]) { int a=6; printf("%6d\n", a); //输出6位整数 return 0; }
#python """ 这是一个多行注释 3个双引号或者单引号 相当于C语言中的/* */注释符 """ a = 3.5 b = 6 print("%.6f"%a,"\t",b) #输出6位小数的浮点数，一个制表符和一个整数
#print中的逗号的位置会在输出中填充一个空格
a = 0 while a < 5: print(a, end = " ") # 指定以空格结尾，而不需要自动换行 a += 1
C语言中的printf函数可以使用%来将输出格式化，在python中使用format函数代替
基本语法是通过 {} 和 : 来代替以前的 % 。format 函数可以接受不限个参数，位置可以不按顺序。
>>>"{} {}".format("hello", "world") # 不设置指定位置，按默认顺序 'hello world' >>> "{0} {1}".format("hello", "world") # 设置指定位置 'hello world' >>> "{1} {0} {1}".format("hello", "world") # 设置指定位置 'world hello world'
变量与运算符
python中有三种类型的变量：数字、字符串和列表
和PHP一样，python中不需要明确的声明一个变量并且定义其变量类型。
常见的运算符和C语言基本都一样，但是python中没有++、--之类的运算符。此外，当需要在一行代码中声明并初始化多个变量时，python有所不同
>>> a=1,b=2 SyntaxError: can't assign to literal >>> a,b=1,2 >>> a,b (1, 2)
python中的除法运算的结果会自动转换成为浮点数，而且python中有两个不同的运算符：取整除和幂运算符：
>>> 8/4 2.0 >>> 8//3 2 >>> 2**3 8
字符串拼接运算：
s1="hello" s2="world" print(s1,s2) #输出结果为hello world print(s1+s2) #输出结果为helloworld
变量类型转换：使用int()、float()和str()进行类型转换，不过这些转换都必须是单步的，换句话说，如果变量的类型需要多步转换才能转换成目标类型的话就会报错
>>> float(2) 2.0 >>> int(3.5) 3 >>> int("2") 2 >>> int("3.5") Traceback (most recent call last): File "<pyshell#12>", line 1, in <module> int("3.5") ValueError: invalid literal for int() with base 10: '3.5'
字符与ASCII表值的转换
>>> ord("a") 97 >>> chr(97) 'a'
列表基础
>>> squares = [1, 4, 9, 16, 25] >>> squares [1, 4, 9, 16, 25]
可以使用下标来访问列表中的元素，也可以使用下标将列表生成一个更小的列表
>>> squares[1]
4
>>> squares[1:4]
[4, 9, 16]
>>> squares[-3:]
[9, 16, 25]
>>> squares[:]
[1, 4, 9, 16, 25]
列表也支持拼接运算
>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
可以使用append()方法来为列表添加元素
>>> cubes = [1, 8, 27, 65, 125] # something's wrong here >>> cubes[3] = 64 # replace the wrong value >>> cubes.append(216) # add the cube of 6 >>> cubes.append(7 ** 3) # and the cube of 7 >>> cubes [1, 8, 27, 64, 125, 216, 343]
也可以通过子列表来更改或者删除列表中的元素
>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g'] >>> letters ['a', 'b', 'c', 'd', 'e', 'f', 'g'] >>> # replace some values >>> letters[2:5] = ['C', 'D', 'E'] >>> letters ['a', 'b', 'C', 'D', 'E', 'f', 'g'] >>> # now remove them >>> letters[2:5] = [] >>> letters ['a', 'b', 'f', 'g']
可以使用内置函数len()来得到列表的长度
>>> letters = ['a', 'b', 'c', 'd'] >>> len(letters) 4
列表也是可以进行嵌套的
>>> a = ['a', 'b', 'c'] >>> n = [1, 2, 3] >>> x = [a, n] >>> x [['a', 'b', 'c'], [1, 2, 3]] >>> x[0] ['a', 'b', 'c'] >>> x[0][1] 'b'
条件控制
if语句
python中的if语句和C语言中的if语句相似，不过python中没有{ } 符号，而是用制表符来表示这些代码属于这个块；此外，C语言中的 else if 对应于python中 elif，C语言中的 || 、&& 和 ! 符号在python中都用 and 和 or 关键字代替。
a = input() #等待用户输入 a = int(a) #用户输入的结果是字符串类型的数据，所以需要进行变量类型的转换 if a > 5: print("a > 5") elif a == 5: print("a = 5") else: print("a < 5")
python中可以直接在条件语句中对字符串中进行大小比较，而不需要像C语言中那样使用strcmp()函数
>>> if 'apple' <'banana': print('wow! python is powerful!') wow! python is powerful!
python中的条件可以直接链接起来，从而省略 and 或者 or 关键字，例如条件语句：a < b == c 用于判断 a 是否小于 b 并且 b 是否等于 c
if条件语句还可以用来对列表或者其他类型的数据结构进行判断处理
>>> t = ['cat','dag','bat'] >>> if t: print('t is not empty') else: print('t is empty') t is not empty >>> if 'cat' in t: print('cat is in t') else: print('cat is not in t') cat is in t
while循环语句
python中的while循环比较简单，和C语言中的while循环没有太大的区别
>>> i = 0 >>> while i < 5: print(i) i += 1 0 1 2 3 4
for循环语句
使用列表进行循环
>>> words = ['cat','dog','window'] >>> for w in words: print(w,len(w)) cat 3 dog 3 window 6
range()函数
>>> for i in range(5): ... print(i) ... 0 1 2 3 4
range()函数的基本格式是：range(startpoint, endpoint, step)，如果只有一个参数，那么range()函数将会把这个参数视为endpoint，startpoint默认为0，step默认为1；如果有两个参数，那么range()函数会将第一个参数赋给startpoint，将第二个参数赋给endpoint，step默认为1；如果有三个参数，则参数对应的方式与range()函数的原型一致。
range(5, 10) 5, 6, 7, 8, 9 range(0, 10, 3) 0, 3, 6, 9 range(-10, -100, -30) -10, -40, -70
使用range()函数进行循环
>>> a = ['Mary', 'had', 'a', 'little', 'lamb'] >>> for i in range(len(a)): print(i,a[i]) 0 Mary 1 had 2 a 3 little 4 lamb
在python中也可以使用关键字break和continue来进行流程控制，其功能和C语言中的一样。
除此之外，python中还有一个关键字pass，pass不会执行任何操作，通常呗用来当作一个占位符
>>> while True: ... pass # Busy-wait for keyboard interrupt (Ctrl+C) >>> class MyEmptyClass: ... pass # Create minimal classes >>> def initlog(*args): ... pass # Used as a placeholder
数据结构
列表
列表类型的变量具有一些内置的方法，下面是列表对象的一些方法的原型以及功能：
list.append(x)，在列表的末尾添加一个值为元素list.extend(iterable)，将一个列表拼接到目标列表中，可以直接使用 + 运算符来代替list.insert(i, x)，在列表下标 i 的位置插入一个值为 x 的元素list.remove(x)，删除列表中第一个值为 x 的元素，如果不存在这个元素则会报错list.pop(i)，删除列表中下标为 i 的元素，并返回这个元素的值，如果没有指定 i 则默认为最后一个元素list.clear()，删除列表中的所有元素，其功能等价于del list[:]list.index(x, start, end)，在下标为start，和end之间的元素中寻找值为 x 的元素，并返回其下标list.count(x)，返回列表中值为 x 的元素的个数list.sort(key=None, reverse=False)，对一个列表进行排序，一般情况下不需要指定参数，只有当需要进行倒序排序（从大到小排序）的时候，需要指定reverse=Truelist.reverse()，将一个列表进行倒置list.copy()，复制列表
>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana'] >>> fruits.count('apple') 2 >>> fruits.count('tangerine') 0 >>> fruits.index('banana') 3 >>> fruits.index('banana', 4) # Find next banana starting a position 4 6 >>> fruits.reverse() >>> fruits ['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange'] >>> fruits.append('grape') >>> fruits ['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape'] >>> fruits.sort() >>> fruits ['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear'] >>> fruits.pop() 'pear'
列表赋值
>>> a = list(range(10)) # 使用list()和range()函数生成列表 >>> a [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> squares = [] >>> for x in range(10): # 常规的方法还是使用循环语句为列表赋值 squares.append(x**2) >>> squares [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>># 上面的循环还可以用下列语句替换 >>> a = [x**2 for x in range(10)] >>> a [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
子列表的处理
>>> vec = [-4, -2, 0, 2, 4] >>> # create a new list with the values doubled >>> [x*2 for x in vec] [-8, -4, 0, 4, 8] >>> # filter the list to exclude negative numbers >>> [x for x in vec if x >= 0] [0, 2, 4] >>> # apply a function to all the elements >>> [abs(x) for x in vec] [4, 2, 0, 2, 4]
del语句
>>> a = [-1, 1, 66.25, 333, 333, 1234.5] >>> del a[0] >>> a [1, 66.25, 333, 333, 1234.5] >>> del a[2:4] >>> a [1, 66.25, 1234.5] >>> del a[:] >>> a [] del a # 删除变量a，如果再次访问a则会报错
元组
元组是多个由逗号分割的数据组成的
>>> t = 12345, 54321, 'hello!' >>> t[0] 12345 >>> t (12345, 54321, 'hello!') >>> # Tuples may be nested: ... u = t, (1, 2, 3, 4, 5) >>> u ((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
但是可以通过为元组重新赋值的方式来改变元组中的元素
>>> s = (1,2,3,4) >>> s (1, 2, 3, 4) >>> s = (4,3,2,1) >>> s (4, 3, 2, 1)
元组中的元素是不可变的，但是元组中如果有可变的数据结构类型的元素的话，那么可以改变该元素中的内容
>>> # Tuples are immutable: ... t[0] = 88888 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment >>> # but they can contain mutable objects: >>> v = ([1, 2, 3], [3, 2, 1]) >>> v ([1, 2, 3], [3, 2, 1]) >>> v[1][0] = 4 >>> v ([1, 2, 3], [4, 2, 1])
需要注意当元组中只有 1 个或 0 个元素的时候，声明元组的语法会比较特殊
>>> empty = () >>> singleton = 'hello', # <-- note trailing comma >>> len(empty) 0 >>> len(singleton) 1 >>> singleton ('hello',) >>> empty ()
集合
集合是python中的一种数据结构，其中的元素没有排序也不会有重复的元素，集合类型的数据对象仍然支持一些数学上的运算，比如并、交、差和对称差
创建一个集合可以使用{}符号将其中的元素放在{}中来进行初始化，也可以使用set()函数来创建，不过当需要创建一个空集合的时候只能使用set()函数
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket) # show that duplicates have been removed
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket # fast membership testing
True
>>> 'crabgrass' in basket
False
>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # unique letters in a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # letters in a but not in b
{'r', 'd', 'b'}
>>> a | b # letters in a or b or both
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # letters in both a and b
{'a', 'c'}
>>> a ^ b # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}
集合也可以像列表那样使用for循环语句进行初始化
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}
字典
python中的字典与PHP中的关联数组非常相似，类似于C语言中的数组，不过这个数组中的每个元素都由一个键值对组成，访问数组中的元素的时候需要使用键来访问相应的值
需要注意的是，python中的字典的键是不可以进行更改的。所以通常字典中的键都是数字或者字符串，当元组中只含有数字或者字符串类型的元素的时候，元组也可以作为字典的键；否则无法使用元组作为某个字典的键。
在python中可以使用list()函数来查看字典中的所有键，如果想要将这些键进行排序，可以直接使用sort()函数。也可以使用关键字 in 来判断字典中是否存在某个键
>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127}
>>> list(tel)
['jack', 'guido', 'irv']
>>> sorted(tel)
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False
可以使用dict()函数直接将一系列键值对生成字典，此外，字典也可以像列表那样使用for循环进行初始化
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)]) {'sape': 4139, 'guido': 4127, 'jack': 4098} >>> {x: x**2 for x in (2, 4, 6)} {2: 4, 4: 16, 6: 36} >>> # When the keys are simple strings, it is sometimes easier to specify pairs using keyword arguments >>> dict(sape=4139, guido=4127, jack=4098) {'sape': 4139, 'guido': 4127, 'jack': 4098}
python中的循环
- 遍历一个字典
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave
- 遍历一个列表以及其下标，使用enumerate()函数
>>> for i, v in enumerate(['tic', 'tac', 'toe']): ... print(i, v) ... 0 tic 1 tac 2 toe
- 遍历两个及两个以上的列表，使用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.
- 倒序遍历一个列表，使用reverse()函数
>>> for i in reversed(range(1, 10, 2)): ... print(i) ... 9 7 5 3 1
- 以从小到大的顺序遍历一个列表，使用sort()函数
>>> 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]
函数
在python中可以直接使用def function_name(): 来创建一个函数
>>> def fib(n): # write Fibonacci series up to n ... """Print a Fibonacci series up to n.""" ... a, b = 0, 1 ... while a < n: ... print(a, end=' ') ... a, b = b, a+b ... print() ... >>> # Now call the function we just defined: ... fib(2000) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
需要注意的是，如果函数中的局部变量和全局变量重名，函数并不会自动调用全局变量，如果需要在调用全局变量，那么需要使用global关键字
此外，将并没有返回结果的函数的值赋给一个变量并不会报错，并且这个变量中的值为None
>>> a = fib(2000) 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 >>> print(a) None
函数中的默认参数往往只赋值一次，但是当参数为可变的数据结构，类似于列表、字典或者某个类时，情况就有所不同
>>> def f(a, L=[]): L.append(a) return L >>> f(1) [1] >>> f(2) [1, 2] >>> f(3) [1, 2, 3]
如果不想让默认参数多次赋值，那么可以这样写
>>> def f(a, L=None):
if L is None:
L = []
L.append(a)
return L
>>> f(1)
[1]
>>> f(2)
[2]
>>> f(3)
[3]
模块
python中的模块就是包含了一些列用python语句定义的函数或者其他数据结构，和其他的python文件一样是以.py为后缀名的文件，这一点和PHP相似。
编写一个名为test的.py文件
def max_func(a,b): if a >= b: return a else: return b
然后使用关键字import来引用test模块
>>> import test >>> test.max_func(1,2) 2
也可以使用from……import语句进行引用，不过在引用模块中的函数时的语句会与import引用模块中的不同
>>> from test import * >>> max_func(1,2) 2
上面代码中的 * 号也可以用某个具体的函数名称代替
也可以使用关键字as对模块或者模块中的函数进行重命名
>>># 重命名模块 >>> import test as t >>> t.max_func(1,2) 2 >>># 重命名模块中的函数 >>> from test import max_func as m >>> m(1,2) 2
dir()函数
dir()函数是python内置函数，用于获取模块被定义的名称，它的返回值是一个字符串列表
>>> ====================== RESTART: D:\Python\Code\test.py ====================== >>> import test >>> dir(test) ['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'max_func'] >>> test.max_func(1,2) 2 >>> dir() ['__annotations__', '__builtins__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'max_func', 'test']
类与对象
python中的类与其他编程语言中的类基本上没有区别，现在定义一个简单的类
>>> class Human: #类的属性 name = 'none' age = 70 #类的方法 def my_name(self): #这里的self参数类似于java中的this，用于指向当前对象自己 print('my name is',self.name) def eat(): # 注意python中的类的方法必须要添加self参数，尽管方法中并不会使用到这个参数 print('eat') def think(self,a,b): print('a + b =',a+b) >>> a = Human() >>> a.my_name() my name is none
在python中的类使用__init()__方法进行初始化
>>> class Complex: def __init__(self, realpart, imagpart): self.r = realpart self.i = imagpart >>> x = Complex(3.0, -4.5) >>> x.r, x.i (3.0, -4.5)
类的继承，在python中，子类继承了父类的所有属性和方法，并且可以在自己的定义中重新定义父类的方法，或者定义属于自己的新的方法
>>> class Student(Human): def __init__(self,school='ECNU',grade=3): super().__init__() # 调用父类的初始化方法 self.school = school self.grade = grade print('Student initial') def learn(): # 定义属于自己的方法 print('learning') def think(self,a,b): # 重写父类的方法 print('a * b =',a*b) >>> stud = Student() Human initial Student initial >>> stud.grade 3 >>> stud.think(1,2) a * b = 2
文件读写
文件读写有两种方式，一种是使用先用open打开文件在进行读写操作，最后一定要记得使用close关闭文件；另一种方式是使用with关键字进行操作，最后则不需要关闭这个文件
>>> my_file = open('file1.txt','w') # 指定以写的方式打开文件，如果不存在则新建一个文件，还可以在文件名的参数中指定文件的存储位置 >>> my_file.write('Hello world!\n') 13 >>> my_file.close() >>> my_file.read() # 无法对已关闭的文件进行操作 Traceback (most recent call last): File "<pyshell#79>", line 1, in <module> my_file.read() ValueError: I/O operation on closed file. >>> my_file = open('file1.txt','r') # 指定以读的方式打开文件 >>> content = my_file.read() >>> print(content) Hello world! >>> my_file.close()
>>> with open('file1.txt','w') as f1: # 使用with中的w方式打开文件在进行写操作时，会将原有的内容删除掉 f1.write('emmmmm?\nWhere is my helloworld?\n') 32 >>> with open('file1.txt','r') as f1: content = f1.read() print(content) emmmmm? Where is my helloworld? >>> with open('file1.txt','a') as f1: # 如果想要追加新的内容，则需要使用a方式打开文件 f1.write('fine, hello world Again\n') 24 >>> with open('file1.txt','r') as f1: content = f1.read() print(content) emmmmm? Where is my helloworld? fine, hello world Again
还可以使用readline()方法来读取文件的第一行，或者使用readlines()方法来读取文件中的所有行
>>> with open('file1.txt','r') as f1: content = f1.readline() # 读取文件的第一行 print(content) emmmmm? >>> with open('file1.txt','r') as f1: content = f1.readlines() # 读取文件的所有行，并放入一个列表中 print(content) ['emmmmm?\n', 'Where is my helloworld?\n', 'fine, hello world Again\n']
也可以使用for循环来遍历文件中的每一行
>>> with open('file1.txt') as f: for line in f: print(line，end='') emmmmm? Where is my helloworld? fine, hello world Again
异常处理
python中的异常处理与Java中的异常处理一样，使用try和except语句进行异常处理，如果try中的语句出现错误，则会执行except中的语句
>>> try: file = open('temp.txt','r+') # 如果打开成功，则可以进行读也可以进行写，如果不存在这个文件，则会打开失败，并出现错误 except Exception as e: print(e) [Errno 2] No such file or directory: 'temp.txt'
也可以在except语句中添加相应的处理机制，来处理这个错误
>>> try: file_name='temp.txt' file = open(file_name,'r+') # 如果打开成功，则可以进行读也可以进行写 except Exception as e: print(e) r = input('Do you want to create a file named {}?(yes/no)'.format(file_name)) if r == 'yes': with open(file_name,'w'): pass print('File created successfully!') else: pass [Errno 2] No such file or directory: 'temp.txt' Do you want to create a file named temp.txt?(yes/no)yes File created successfully!
还可以在后面添加else语句，用于执行当没有错误发生的时候的代码
>>> try: file_name='temp.txt' file = open(file_name,'r+') # 如果打开成功，则可以进行读也可以进行写 except Exception as e: print(e) r = input('Do you want to create a file named {}?(yes/no)'.format(file_name)) if r == 'yes': with open(file_name,'w'): pass print('File created successfully!') else: pass else: # try语句中没有发生错误时可以执行下面的语句 file.write('Python is so cool!\n') file.close() 19 >>> with open(file_name,'r') as f: content = f.read() print(content) Python is so cool!
