想知道一个对象的类型：type(thing)

例如：type(123)    type(‘adf’)   type(12.2)

运算符  
 描述
 
示例
  运算结果

 /               浮点数除法·
7 / 2
3.5

//
  整数除法
7 // 2
3

**               幂
3 ** 4 
81

divmod的函数:同时得到商和余数

divmod(9,5)     (1,4)

基数

0b或0B代表二进制，0o或0O代表八进制，0x或0X代表十六进制

类型转换

>>> int(True)     1

>>> int(False)    0

>>> int(98.6)     98

>>> int(1.0e4) 10000

>>> int(’99’)     99

>>> int(‘+99’)     99

>>> int(‘-99’)     -99

但是

>>> int(‘98.6’) 会报错

>>> int(‘1.0e4’) 会报错

混合使用不同数字类型计算，python会自动地进行类型转换：

>>> 4 + 7.0        11.0

>>> True + 2     3

浮点数

>>> float(true)       1.0

>>> float(False)
0.0

>>> float(‘98.6’)
98.6

>>> float(‘1.0e4’)
10000.0

Python的int类型无限大，任意存储，超过64位，python处理超大数计算不会产生任何错误

字符串

使用引号创建字符串：单引号和双引号
混合使用的好处：可以创建本身就包含引号的字符串，而不用使用转义字符

三元引号（”’三个单引号”’   |  “””三个双引号”””）：用来创建多行字符串

str（）类型转换

>>> str(98.6)
‘98.6’

>>> str(1.0e4)
‘10000.0’

>>> str(True)
‘True’  (好奇居然不是’1′)

使用+拼接：进行字符串拼接时，Python并不会自动为你添加空格，在print（）进行拼接打印时，会自动添加空格，并在结尾添加换行符。

使用*复制  >>> ‘na’ * 4          ‘nananana’

使用[]提取字符串：最后一个字符的偏移量可以用-1表示

使用[start:end:step]分片

[start:end:step] 从start提取到end – 1， 每step个字符提取一个， 三者都可以省略

如果step为负数，python还会从右到做反向进行提取操作

使用len()获取长度

>>> empty = “”

>>>len(empty)       0

使用split()分割，不指定分隔符，默认使用空白符号–换行符，空格，制表符

>>> todos = ‘get,gloves,getted’

>>> todos.split(‘,’)

[‘get’,’gloves’,’getted’]

使用join()合并

>>> todos = [‘get’,’gloves’,’getted’]

>>> ‘\n’.join(todos)     (使更多子串合并成完整的字符串)

>>> poem = ”’All the that  doth flow we

        cannot liquid name double….”’

>>> poem.startswith(‘All’)      True #判断是不是以All开头

>>> poem.endswith(‘dkfj’)     False       #判断是否以dkfj结尾

>>> poem.find(‘the’)        4        #第一次出现单词the的位置

>>> poem.rfind(‘the’)4       #最后一次出现单词the的位置

>>> poem.count(‘the’)1#计算出现多少次 

>>> poem.strip(‘.’)#将字符串收尾的，都删除掉

>>> poem.capitalize()#字符串首字母变大写

>>> poem.title()#所有单词的开头字符变大写

>>> poem.upper()#让所有字母都变大写

>>> poem.lower()#让所有字母都变成小写

>>> poem.swapcase()#让所有字母的大小写转换

>>> poem.replace(‘the’,’mar’)#替换

>>> poem.replace(‘the’,’mar’，100)#最多替换100次

Python容器： 列表，元组，字典与集合

列表

使用[ ]或者list()创建列表

使用list()将字符串和数组转换成列表

>>> list(‘cat’)    [‘c’,’a’,’t’]

>>> a_tuple = (‘c’,’a’,’t’)

>>> list(a_tuple) [‘c’,’a’,’t’]

>>> marxes = [‘c’,’a’,’t’]

>>> marxes[0:2] [‘c’,’a’] #指定范围并使用切片提取元素

使用append()添加元素至尾部

使用extend（）或者+= 合并列表

>>> marxes.insert(2,’ee’) #指定位置插入元素

>>> del marxes[2] #删除指定位置的元素

>>> marxes.remove(‘c’) #删除具体指定值得元素

>>> marxes.pop(1) #获取并删除指定位置的元素

>>> marxes.index(‘t’) #查询具体特定值的元素位置

>>> ‘t’ in marxes True #判断值是否存在

>>> marxes.count(‘t’) 1#记录特定值出现的次数

使用sort（）重新排列元素，默认是升序的，添加参数reverse= True 可以改为降序排列

使用copy()函数把一个列表的值复制到另一个新的列表中

元组

使用（）创建元组

>>> m_tuple = (‘a’,’b’,’c’)

>>> a,b,c = m_tuple#一口气将元组赋值给多个变量（元组解包）

tuple()函数可以将其他类型的数据创建元组

字典 (不会出现重复的key,排列无顺序)

使用{}创建字典

使用ditc()转换成字典

>>> pythons = {‘a’:’aa’, ‘b’:’bb’}

>>> pythons[‘a’] = ‘aaa’

使用update()合并字典

使用del删除具有指定键的元素

使用clear（）删除所有元素

使用in判断是否存在

使用keys()获取所有键

使用values()获取所有值

使用items()获取所有键值对，每个键值对以元组的形式返回

使用=赋值，使用copy()复制

集合 （类似舍弃了值，仅剩下键的字典，无序）

使用set()创建集合，也可将其他类型转换为集合

>>> set(‘let’) {‘l’,’e’,’t’}

当字典作为参数传入set()函数时，只有键会被使用

合并及运算符

通过使用&符号或者集合函数insertsection（）获取两个集合的交集

使用 | 符号或者union（）函数获取两个集合的并集

使用 – 符号或者difference()函数获取两个集合的差集

使用 ^ 符号或者symmetric_difference()函数获取两个集合的异或集（仅两个集合中出现一次）

使用<= 符号或者issubset()判断是否第一个集合的所有元素是否出现在第二个集合中（第2是第1的超集））

使用< 符号表示真子集

使用>= 符号或者issupserset()判断第二个集合的所有元素是否都出现在第一个集合中

代码结构

使用#注释

使用行连接符 \ 进行连接

>>> al = ‘asdf’ + \

…‘dfsdf’ + \

…‘sdrfs’

>>> al

‘asdfdfsdfsdrfs’

使用if，elif（即else if）和else进行比较

真值比较

>>> x = 7

>>> 5 < x < 10#python允许这样做

True

下面的情况会被认为是false

布尔False

null类型None

整形0

浮点数0.0

空字符串”

空列表[]

空元组()

空字典{}

空集合set()

剩下的情况都会被认为是真值

使用while进行循环，使用break跳出循环，使用continue跳出循环开始

>>> count = 1

>>> while count <= 5:

…print(count)

…count +=1

循环外使用else（循环中没有调用break后执行的检查）

…
else:
#没有执行break

…       print(‘nihao’)

使用for迭代(列表，字符串，元组，字典，集合)

>>> rabbits = [‘a’,’b’,’c’]

>>> for rabbit in rabbits:

…print(rabbit)

for也可以循环外使用else

使用zip（）并行迭代

>>> days=[‘M’,’T’]

>>> fruits = [‘apple’, ‘peach’]

>>> for day, fruit in zip(days, fruits):

…print(day, “: eat”, fruit)

zip（）函数在最短序列用完时就会停止

zip（）的返回值既不是元组也不是列表，而是一个整合一起的迭代变量

>>> english = ‘m’,’n’

>>> freanch = ‘L’,’a’

>>> list(zip(english, freanch))[(‘m’,’L’),(‘n’,’a’)]

>>> dict(zip(0english,freanch)){‘m’:’L’, ‘n’:’a’}

使用range()生成自然数序列，返回的是可迭代的对象

range（start，stop，step），start默认是0，产生的最后一个数是stop的前一个，step默认是1

推导式

列表推导式

>>> number_list = [number for number in range(1,6)]#第一个number变量为列表生成值，第二个是循环变量

>>> number_list

[1,2,3,4,5,6]

>>> number_list = [number for number in range(1,6) if number % 2 == 1]

>>> number_list

[1,3,5]

>>> rows = range(1,4)

>>> cols = range(1,3)

>>> cells = [(row, col) for row in rows for col in cols]

>>> for cell in cells:

…print(cell)

>>>for row,col in cells:

…print(row, col)

字典推导式

>>> word = ‘letters’

>>> letter_counts = {letter : word.count(letter) for letter in set(word)} #set(word)可以避免可能发生同个字符多次调用count()，浪费时间的现象

>>> letter_counts

{‘s’: 1, ‘t’: 2, ‘l’: 1, ‘r’: 1, ‘e’: 2}

集合推导式

>>> a_set = {number  for number in range(1,6) if number % 3 == 1}

>>> a_set

{1,4}

生成器推导式

元组没有推导式，生成器推导式返回的是一个生成器对象，一个生成器只能运行一次，不会被存下来，不能重新使用或者备份一个生成器

>>> number_thing = (number for number in range(1,6))

>>> type(number_thing)

<class ‘generotor’>

函数

定义函数用def

不显示调用return函数,会返回默认的None

>>> def agree():

…     return True

…

>>> print(agree())

True

位置参数：按顺序一次复制过去

关键字参数：调用时指定对应参数名，位置和关键两种方式混合使用时，位置参数必须放置于关键参数之前

>>> def menu(wine,entree,dessert):

…     return{‘wine’:wine,’entree’: entree, ‘dessert’ : dessert}

…

>>> menu(‘chardonnay’,’chicken’,’cake’)

{‘wine’: ‘chardonnay’, ‘entree’: ‘chicken’, ‘dessert’: ‘cake’}

>>> menu(entree=’beef’, dessert=’bagel’, wine = ‘bordeaux’)

{‘wine’: ‘bordeaux’, ‘entree’: ‘beef’, ‘dessert’: ‘bagel’}

>>>

指定默认参数值

>>> def menu(wine,entree,dessert=’pndding’):


…     return{‘wine’:wine,’entree’: entree, ‘dessert’ : dessert}


…

下面程序出现只有第一次调用时列表是空的

>>> def buggy(arg, result=[]):
…     result.append(arg)
…     print(result)
…
>>> buggy(‘a’)
[‘a’]
>>> buggy(‘b’)
[‘a’, ‘b’]

修改为

>>> def buggy(arg, result=None):


…if result is None:

…result = []

…     result.append(arg)


…     print(result)


…


>>> buggy(‘a’)


[‘a’]


>>> buggy(‘b’)


[‘b’]

使用*收集位置参数

>>> def print_args(*args):

…     print(‘positional argument tuple:’, args)

…

>>> print_args()

positional argument tuple: ()

>>> print_args(3,2,1)

positional argument tuple: (3, 2, 1)

>>>def print_args(required1,required2, *args):
#*args会收集剩下的参数

使用**收集关键字参数

>>> def print_kwargs(**kwargs):

…     print(‘Keyword arguments:’,kwargs)

…

>>> print_kwargs(wine=’merlot’, entree=’mutton’, dessert=’macaroon’)

Keyword arguments: {‘wine’: ‘merlot’, ‘entree’: ‘mutton’, ‘dessert’: ‘macaroon’}

文档字符串

>>> def echo(anything):

…     ‘echo returns its input arugment’

…     return anthing

…

>>> print(echo.__doc__)
#双下划线，仅仅获取文档字符串

echo returns its input arugment

>>>

一等公民：函数

函数可以作为参数被其他函数调用

>>> def answer():

…     print(42)

…

>>> def run_something(func):

…     func()

…

>>> run_something(answer)

42

>>> type(run_something)

<class ‘function’>

sum（）是python的一个内建函数

>>> def sum_args(*args):

…     return sum(args)

…

>>> def run_with_positional_args(func, *args):

…     return func(*args)

…

>>> run_with_positional_args(sum_args, 1,2,3,4)

10

内部函数（当需要在函数内部多次执行复杂的任务时，可以避免了循环和代码的堆叠重复）

>>> def outer(a,b):

…     def inner(c,d):

…             return c + d

…     return inner(a,b)

…

>>> outer(4,7)

11

闭包（一个呗动态创建的可以记录外部变量的函数）

inner2()直接使用外部的saying参数，不用通过另一个参数获取，inners（）返回的是inner2函数，而不是调用它

>>> def knigts2(saying):

…     def inner2():

…             return “We are the knights who say: ‘%s'” % saying

…     return inner2

…

>>> a = knigts2(‘Duck’)

>>> type(a)

<class ‘function’>

>>> a

<function knigts2.<locals>.inner2 at 0x0000019B176ECE18>

>>> a()

“We are the knights who say: ‘Duck'”

匿名函数： lambda()函数（可以用来代替小的函数）

>>> def edit_story(words, func):

…     for word in words:

…             print(func(word))

…

>>> stairs = [‘thud’,’meow’,’thud’]

>>> def enliven(word):

…     return word.capitalize() + ‘!’

…

>>> edit_story(stairs, enliven)

Thud!

Meow!

Thud!

>>> edit_story(stairs, lambda word: word.capitalize() + ‘!’)

Thud!

Meow!

Thud!

生成器函数（返回值使用yield语句声明）

>>> def my_range(first=0, last = 10, step=1):

…     number = first

…     while number < last:

…             yield number

…             number += step

…

>>> my_range

<function my_range at 0x0000019B176F5048>

>>> ranger = my_range(1,5)

>>> ranger

<generator object my_range at 0x0000019B176EB150>

>>> for x in ranger:

…     print(x)

…

1

2

3

4

>>> for a in ranger:    #生成器对象只能运行一次

…     print(a)

…

>>>

装饰器

>>> def document_it(func):

…     def new_function(*args, **kwargs):

…             print(‘Running function:’, func.__name__)

…             result = func(*args, **kwargs)

…
print(‘Result:’, result)

…             return result

…     return new_function

…

>>> def add_ints(a,b):

…     return a + b

…

>>> cooler_add_ints = document_it(add_ints)   #人工对装饰器赋值

>>> cooler_add_ints(3,5)

Running function: add_ints

8

另外，可以直接在要装饰的函数前添加装饰器名字@decorator_name:

>>> @document_it

… def add_ints(a,b):

…     return a + b

…

>>> add_ints(3, 5)

Running function: add_ints

Result： 8

8

>>>

同一个函数可以有多个装饰器,靠近函数定义的装饰器最先被执行，然后一次执行上面的

>>> def square_it(func):

…     def new_function(*args, **kwargs):

…             result = func(*args, **kwargs)

…             return result * result

…     return new_function

…

>>> @document_it

… @square_it

… def add_ints(a,b):

…     return a + b

…

>>> add_ints(3,5)

Running function: new_function

Result： 64

64

交换两个装饰器的顺序

>>> @square_it

… @document_it

… def add_ints(a,b):

…      return a + b

…

>>> add_ints(3,5)

Running function: add_ints

Result： 8

64

这个地方有点绕，去百度了一下，还是有点懵逼

命名空间和作用域

python内嵌函数id（）打印输出每一个对象的唯一的ID值

>>> animal = ‘fruitbat’

>>> def change_and_print_global():

…
global animal

…     animal =’wombat’

…

>>> change_and_print_global()

>>> animal

‘wombat’

python提供两个获取命名空间内容的函数：

locals（）返回一个局部命名空间内容的字典

globals（）返回一个全局命名空间内容的字典

使用try和except处理错误

>>> short_list = [1,2,3]

>>> position = 5

>>> try:

…     short_list[position]

… except:

…     print(‘error’)

…

error

>>>

获取异常对象

excep exceptiontype as name

编写自己的异常

>>> class UppercaseException(Exception):

…     pass

…

>>> words= [‘eenie’,’meenie’,’miny’，‘MO’]

>>> for word in words:

…     if word.isupper():

…             raise UppercaseException(word)

…

访问异常对象本身，并且输出它：

>>> try:

…
raise OopsEexception(‘panic’)

…
except OopsException as exc:

…
print(exc)

panic

本文是我在学习了丁嘉瑞的《Python语言及其应用》所做的笔记，只用于学习。