本文共 3611 字，大约阅读时间需要 12 分钟。

数据类型

1. 整数

2. 浮点数

3. 字符串

1. 以单引号'或双引号"括起来的任意文本    2. 转义字符 \    3. r''表示''内部的字符串默认不转义

>>> print('\\\t\\')\\>>> print(r'\\\t\\')\\\t\\

4. '''...'''的格式表示多行内容

>>> print('''line1... line2... line3''')line1line2line3

4.布尔值

True、False

5.空值

None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

6.变量

变量名必须是大小写英文、数字和_的组合，且不能用数字开头

7.常量

通常用全部大写的变量名表示常量

ps:

/   计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数//  称为地板除，两个整数的除法仍然是整数%  可以得到两个整数相除的余数

字符串和编码

1. ord()函数获取字符的整数表示
2. chr()函数把编码转换为对应的字符

3. 对bytes类型的数据用带b前缀的单引号或双引号

   x = b'ABC'

4. encode()方法可以编码为指定的bytes

   decode()可以编码为指定的str
   计算str包含多少个字符，可以用len()函数

5. %运算符就是用来格式化字符串

list和tuple

list [ ]

1. list是一种有序的集合，可以随时添加和删除其中的元素
2. 用len()函数可以获得list元素的个数
3. appent(x) 追加到末尾
4. insert(index,x) 追加到index处
5. pop()弹出末尾元素
   pop(index) 弹出index处元素

tuple ( )

1. 有序列表,一旦初始化就不能修改
2. 只有1个元素的tuple定义时必须加一个逗号,

条件判断

if 
   <条件判断1>
    :    
    <执行1>
     elif 
     <条件判断2>
      :    
      <执行2>
       elif 
       <条件判断3>
        :    
        <执行3>
         else: 
         <执行4>
        
       
      
     
    
   

循环

for in 循环

依次把list或tuple中的每个元素迭代出来

names = ['Michael', 'Bob', 'Tracy']for name in names:    print(name)

>>> list(range(5))[0, 1, 2, 3, 4]

while循环

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

使用dict和set

dict {key:value,key:value…}

键-值（key-value）存储

避免key不存在的错误

1. 通过in判断key是否存在
2. 通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value：

>>> d.get('Thomas')>>> d.get('Thomas', -1)-1

pop(key)方法删除key，对应的value也会从dict中删除

Set {key1,key2…}

和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key

1. s = set([1, 1, 2, 2, 3, 3])
2. add(key)方法可以添加元素到set中，可以重复添加，但不会有效果
3. remove(key)方法可以删除元素

函数

定义函数

1. def 函数名、括号、括号中的参数和冒号:
2. 空函数 函数体用pass
3. 参数检查

def my_abs(x):    if not isinstance(x, (int, float)):        raise TypeError('bad operand type')    if x >= 0:        return x    else:        return -x

4. 默认参数

def power(x, n=2):    s = 1    while n > 0:        n = n - 1        s = s * x    return s

必须指向不变对象

def add_end(L=None):    if L is None:        L = []    L.append('END')    return L

5. 可变参数

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple

def calc(*numbers):    sum = 0    for n in numbers:        sum = sum + n * n    return sum

ps

*nums表示把nums这个list的所有元素作为可变参数传进去

6. 关键字参数

关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict

def person(name, age, **kw):    print('name:', name, 'age:', age, 'other:', kw)

7. 命名关键字参数

只接收city和job作为关键字参数

def person(name, age, *, city, job):    print(name, age, city, job)

如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了

8. 参数组合

必选参数、默认参数、可变参数、命名关键字参数和关键字参数

高级特性

切片

1. L[a:b] 取索引a-b的元素
2. 倒数切片
3. 间隔 L[a:b:n]

迭代

1. 迭代list

for (i=0; i

2. 迭代dict

2.1 迭代key

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

2.2 迭代value

for value in d.values()

2.3 同时迭代key和value

for k, v in d.items()

3. 迭代str

>>> for ch in 'ABC':...     print(ch)...ABC

4.判断一个对象是可迭代对象

>>> from collections import Iterable>>> isinstance('abc', Iterable) # str是否可迭代True>>> isinstance([1,2,3], Iterable) # list是否可迭代True>>> isinstance(123, Iterable) # 整数是否可迭代False

5.enumerate()

>>> for i, value in enumerate(['A', 'B', 'C']):...     print(i, value)...0 A1 B2 C

列表生成式

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

加上if判断

>>> [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']

高阶函数

1. map

   map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回

>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))['1', '2', '3', '4', '5', '6', '7', '8', '9']

2.reduce

reduce把一个函数作用在一个序列[x1, x2, x3, …]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

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

转载地址：http://stqli.baihongyu.com/