python学习笔记

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
", a);     //输出6位整数
    return 0;
}

#python

"""
这是一个多行注释

3个双引号或者单引号

相当于C语言中的/* */注释符
"""
a = 3.5
b = 6
print("%.6f"%a,"	",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=True
• list.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:PythonCode	est.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!
')
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?
Where is my helloworld?
')

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

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?
', 'Where is my helloworld?
', 'fine, hello world Again
']

 也可以使用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!
')
    file.close()

19
>>> with open(file_name,'r') as f:
    content = f.read()
    print(content)

Python is so cool!