1
2
3
4

>>> ord('A')
65
>>> ord('中')
20013

1
2
3
4

>>> chr(66)
'B'
>>> chr(25991)
'文'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

>>> 'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'

>>> b'ABC'.decode('ascii')
'ABC'
>>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
'中文'.encode('ascii') 

#报错
>>> '中文'.encode('ascii')
>>> b'\xe4\xb8\xad\xff'.decode('utf-8')

#忽视少数字符
>>> b'\xe4\xb8\xad\xff'.decode('utf-8',errors='ignore')
'中'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

>>> len(b'ABC')
3
>>> len(b'\xe4\xb8\xad\xe6\x96\x87')
6
>>> len('中文'.encode('utf-8'))
6
>>> len('ABC')
3
>>> len('中文')
2

1
2
3
4
5
6

if salary >= 10000:
	print('happy')
elif salary >= 5000:
	print('common')
else:
	print('sad')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#for循环
sum = 0
for x in [1,2,3,4,5,6,7,8,9]:
	sum = sum + x
print(sum)

#range函数生成证书序列，和list()函数转换为list
>>> list(range(5))
[0,1,2,3,4]

#举例
sum = 0
for x in range[101]:
	sum = sum + x
print(sum)
else:
	没有通过nreak跳出循环，循环结束后会执行的代码
5050

#while循环
sum = 0
n = 99
while n > 0 :
    sum = sum + n
    n = n-2
print(sum)

##break和continue两函数与C语言用法一样

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#取值,索引超出范围会报错
list[0]
#取索引，数据不在列表内会报错
list.index('')
#修改数据,索引超出范围会报错
list[1] = '李四'
#增加数据，append会插到最后,insert会插到指定索引前面,extend可以把一个列表追加到当前列表末尾
#列表中使用+=运算符会直接调用列表的extend()方法
#相加再赋值,并不会调用extend()方法
list.append('李四')
list.insert(1,'李四')
list.extend(name_list)
#删除数据，remove会删除第一个出现的元素，元素不存在时，会报错。clear会把列表清空，pop默认把列表最后一个元素删除，同时可以指定删除元素的索引.建议使用前三个方法。del关键字本质上是将一个变量从内存中删除
list.remove('李四')
list.pop(3)
list.clear()
del list[0]
#统计,len统计列表元素个数，count统计某个元素出现的个数
len(list)
list.count('李四')
#列表排序，sort升序排列，sort(reverse=True),list.reverse()降序排列
list.sort()
list.sort(reverse=True)
list.reverse()

1

classmates = ['a','b','c']

1
2
3
4
5
6
7

#第一种，正序访问
classmates[0]
classmates[1]
classmates[2]
#第二种，逆序访问
classmates[0] = classmates[-3]
classmates[2] = classmates[-1]

1
2
3

>>> classmates.append('d')
>>> classmates
['a','b','c','d']

1
2
3

>>> classmates.insert(1,'d')
>>> classmates
['a','d','b','c','d']

1
2
3
4
5
6
7
8

>>> classmates.pop()
'd'
>>> classmates
['a','d','b','c']
>>> classmates.pop(1)
'd'
>>> classmates
['a','b','c']

1
2
3

>>> classmates[1] = 'd'
>>> classmates
['a','d','c']

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

>>> L = ['a',123,True]
>>> s = ['a','b',['c','d'],'d']
>>> len(s)
4
#等同于以下
>>> p = ['c','d']
>>> s = ['a','b',p,'d']
>>> len(s)
4
#预访问C，可采用一下两种形式
>>> p[0]
>>> s[2][0]
#空list
>>> L = []
>>> len(L)
0

1
2
3
4
5
6

#获取索引
info.index('李四')
#获取某数据出现的次数
info.count('李四')
#统计元素格式
len(info)

1
2
3
4
5
6
7
8
9

>>> t = (1,)
>>> t
(1,)
#否则会产生这样的歧义
>>> t = (1)
>>> t
1
#定义空元组
t = ()

1
2
3
4
5

>>> t = (0,1,['A','B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
(0,1,['X','Y'])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#取值,如果key值不存在，则会报错
person_dict['key']
#增加'key'不存在，则增加
persion_dict['key'] = 18
#修改，'key'存在，则修改
persion_dict['key'] = 20
#删除
persion_dict.pop('key')
#统计键值对的数量
len(person_dict)
#合并字典,被合并的字典中包含已经存在的键值对，会覆盖原有的键值对
person_dict.update(dict)
#清空
persion_dict.clear()
#循环遍历
#k是每一次循环中，获取的键值对的key
for k in persion_dict :
    print('%s - %s' % (k,persion_dict[k]))

1
2
3

>>> d = {'a' : 95,'b' : 75,'c' : 85}
>>> d['a']
95

1
2
3

>>> d['d'] = 67
>>> d['d']
67

1
2
3

>>> d['a'] = 90
>>> d['a']
90

1
2
3
4
5
6
7

#方法一
>>> 'e' in d
False
#方法二,如果不存在返回none或者指定的值，none在交互环境下不显示结果
>>> d.get('e')
>>> d.get('e',-1)
-1

1
2
3
4

>>> d.pop('a')
90
>>> d
{'b' : 75,'c' : 85,'d' : 67}

1
2
3
4
5
6

#统计字符串长度
len(str)
#统计某子字符串出现的次数
str.count("llo")
#某一个子字符串出现的位置,该子字符串不存在时会报错
str.index("llo")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#普通定义
def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x
    
#空语句,可以作为占位符
pass


#空函数
def empty():
    pass

#当传入参数个数不对时，会报错
#手动参数检查
def my_abs(x):
    if not isinstance(x,(int,float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x
    
#返回多个值
import math
def mov(x,y):
    nx = x + 1
    ny = y + 1
    return nx,ny
#函数的返回值实际上是tuple类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

#位置参数
def power(x):
    return x*x
#调用 power(3)

def power(x,n):
    s = 1
    while n > 0:
        n = n-1
        s = s * n
    return s
#调用 power(3,4)

#默认参数
#必选参数在前，默认参数在后，否则会报错,多个参数时，将变化大的放前面，变化小的放后面
#默认参数没有按默认顺序输入时，需要把参数名写上
def power(x,n=2)
	s = 1
    while n > 0:
        n = n - 1
        s = s * n
    return s
#调用 power(3)或power(3,4)

def enroll(name, gender, age=6, city='Beijing'):
    print('name:', name)
    print('gender:', gender)
    print('age:', age)
    print('city:', city)
#调用 enroll('Sarah', 'F') 或  enroll('Sarah', 'F'，7)或 enroll('Sarah', 'F'，city = 'TianJin')

#可变参数(可参照C语言的指针)
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4]);
   print("函数内取值: ", mylist)
   return
mylist = [10,20,30];
changeme( mylist );
print("函数外取值: ", mylist)
#结果 函数内取值:  [10, 20, 30, [1, 2, 3, 4]]，函数外取值:  [10, 20, 30, [1, 2, 3, 4]]
#将其中可变参数变为不可变参数
def changeme( mylist = None):
   "修改传入的列表"
   mylist.append([1,2,3,4]);
   print("函数内取值: ", mylist)
   return
mylist = [10,20,30];
changeme( mylist );
print("函数外取值: ", mylist)
#结果 函数内取值:  [10, 20, 30, [1, 2, 3, 4]]，函数外取值:  [10, 20, 30]
#可变参数使用
def calc(numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
#此方式必须传入list或者dict
def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
#此方式可直接如下调用calc(1,2,3,4) 如果有num =  [1,2,3]，那么直接调用calc(*num)


#关键字参数(用于传递dict，传入时可以省略)
#传入任意个数时
def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw）
>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
#限制关键字参数名字
def person(name, age, *, city, job):
    print(name, age, city, job)

1

#类似于C语言

1
2
3
4
5
6
7

 L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
 L[0:3] = L[:3] = ['Michael', 'Sarah', 'Tracy']
 L[-2:] = ['Bob', 'Jack']
 
 L = list(range(100))
 L[:10:2] = [0, 2, 4, 6, 8]
 L[::5] = [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for key in d:
...     print(key)
...
a
c
b

#如果要迭代value，可以用for value in d.values()，如果要同时迭代key和value，可以用for k, v in d.items()

>>> for i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C
#Python内置的enumerate函数可以把一个list变成索引-元素对
>>> for x, y in [(1, 1), (2, 4), (3, 9)]:
...     print(x, y)
...
1 1
2 4
3 9

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#普通用法(注意与生成式区分)
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>
>>> for n in g:
...     print(n)
... 
0
1
4
9
16
25
36
49
64
81
#通过函数来构建生成器
#在执行过程中，遇到yield就中断，下次又继续执行。
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>

1
2

for x in [1, 2, 3, 4, 5]:
    pass

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

1
2
3
4
5

def add(x,y,f):
    return f(x) + f(y)
#调用
>>> print(add(-5,6,abs))
11

1
2
3
4
5
6

>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

1
2
3
4
5
6

>>> from functools import reduce
>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

1
2
3
4
5

def is_odd(n):
    return n % 2 == 1

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 结果: [1, 5, 9, 15]

1
2
3
4

>>> sorted([36, 5, -12, 9, -21])
[-21, -12, 5, 9, 36]
>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]

1
2
3

import a
a.printa()
a.name

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

' a test module '

__author__ = 'Michael Liao'

import sys

def test():
    args = sys.argv
    if len(args)==1:
        print('Hello, world!')
    elif len(args)==2:
        print('Hello, %s!' % args[1])
    else:
        print('Too many arguments!')

if __name__=='__main__':
    test()

1
2
3
4
5

class 类名:
    def 方法一(self,参数):
        pass
    def 方法二(self,参数):
        pass