2022年 11月 8日

Python语言及其应用

Python3语言及其应用

想知道一个对象的类型: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后执行的检查)

>>> while count <= 5:
…print(count)
if count == 2:
break;
…count +=1


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-1 for number in range(1,6)]#第一个number变量为列表生成值,第二个是循环变量
>>> number_list
[0,1,2,3,4,5]

>>> 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语言及其应用》所做的笔记,只用于学习。