Python笔记

PYTHON

学习之旅

 

基础知识... 3

列表list：... 5

生成器：... 6

元组tuple: 7

切片：... 7

字典dict 7

set 8

惰性计算... 8

迭代：... 8

迭代器：... 9

If语句... 10

函数... 10

map()函数... 11

reduce()函数... 11

filter()函数... 11

sorted()函数... 12

返回函数... 12

匿名函数... 13

装饰器... 13

偏函数... 14

参数组合：... 15

递归函数：... 15

模块：... 16

类... 16

数据封装... 17

继承... 17

多态... 18

使用@property. 18

多重继承... 19

获取对象信息... 19

使用type. 19

使用isinstance. 20

使用dir（）... 20

使用 _slots_. 20

定制类... 21

_str_和_repr_. 21

_iter_. 21

枚举类... 22

错误处理... 22

try的用法：... 22

基础知识

用print()函数打印指定文字，把希望打印的文字用单引号或双引号括起来，print()遇到“，”会输出一个空格

用单引号或双引号括起来的叫字符串

用exit()退出Python

input()输入函数，可以让用户输入对应的字符串

布尔值：布尔值和布尔代数的表示完全一致，一个布尔值只有True,  False（注意大小写）两个值中一个

and（与运算）运算，只有所以都是True，and运算才是True

or（或运算）运算，只要其中有一个True,or运算就是True

not运算（非运算），可以把True变成False

None（空值），不能用0表示（0是有意义的），None是一个特殊空值

变量不能用数字开头，符号只能有“_”

/（除法）计算结果是浮点数，10/3=3.333333333335

//（地板除）计算结果是整数，10//3=3

%（余数）计算结果是余数，10%1=1

Python的浮点数没有大小限制，超过一定范围用inf（无限大）表示

8个比特（bit）作为一个字节（byte）,所以一个字节能表示的最大整数是255（二进制11111111=十进制255）

UTF-8编码

ord()函数获取字符的整数表示，chr()函数把编码转换为相应的字符

python的字符串类型是str，将str变为以字节为单位的bytes,bytes类型的数据用前缀带b的单引号或双引号表示：x =b’abc’,注意 ：’abc’和b’abc’前者是str,虽然内容一样，但是bytes的每个字节都只用一个字节

格式化：用%实现

%d 整数 %f 浮点数 %s 字符串 %x 十六进制整数

%s对任何数据类型取作用

'Hi, %s, you have $%d.' % ('Michael', 1000000)

'Hi, Michael, you have $1000000.'

显示单词"ada lovelace"

name = "ada lovelace"
print(name.title())以首字母大写的方式显示每个单词

print(name.upper())以全大写的方式显示每个单词
print(name.lower())以全小写的方式显示每个单词

绝对值函数 abs（）

换行     空格

str()将非字符串值表示为字符串,str不能直接与整数作比较，必须先把str转换为整数

if _name_ == ‘_nain_’:语句表示在一个.py文件中，如果运行该文件自身，那么_name_值就是‘_nain_’；如果它被别的文件导入的（该.py文件作为模板），则它的_name_就不是‘_nain_’。

所以if _name_ == ‘_nain_’中的命令只能在它独立运行时才执行

列表list：

用方括号（[]）来表示list，并用逗号来分隔其中的元素,list是可变序列，可以通过索引对元素取值，索引从零开始。

方法append()将元素'（‘’）'添加到了列表末尾

方法insert()可在列表的任何位置添加新元素。为此，你需要指定新元素的索引和值。insert(0, 'ducati')

如果知道要删除的元素在列表中的位置，可使用del语句

方法pop()可删除列表末尾的元素和列表中任意位置元素，并让你能够接着使用它。

你只知道要删除的元素的值，可使用方法remove()。

方法sort()永久性地修改了列表元素的排列顺序（按字母），只需向sort()方法传递参数
reverse=True反向排列

###要保留列表元素原来的排列顺序，同时以特定的顺序呈现它们，可使用函数sorted()，只需向sorted()方法传递参数reverse=True反向排列

要反转列表元素的排列顺序，可使用方法reverse()。与字母顺序无关

使用函数len()可快速获悉列表的长度

range()让你能够轻松地生成一系列的数字

min(digits)计算数列最小值
max(digits) 计算数列最大值
sum(digits) 计算数列总和

列表生成式：

list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用 list(range(1, 11))

[x * x for x in range(1, 11) if x % 2 == 0] 生成

[4, 16, 36, 64, 100]

生成器：

      一边循环一边计算的机制就是生成器（generator）

方法一：把一个列表生成式的[]改为（），就创建了一个generator

     L = [x * x for x in range(10)]

>>> L [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> g = (x * x for x in range(10))

>>> next(g)

>>>0

for n in g:

... print(n)

生成器可以通过next()函数打印打印generator的下一个值

因为generator是可迭代对象，所以可以用for循环

方法二：如果一个函数中包含了yield关键字，那就是一个generator。执行过程中，遇到 yield就中断，下次又从yield处继续执行。

 

元组tuple:

       元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。Python将不能修改的值称为不可变的，而不可变的列表被称为元组。

      只有 1 个元素的 tuple 定义时必须加一个逗号,，来消除歧义:t = (1,)

切片：

     取一个list或tuple的部分元素。索引从0开始

     列：a[1,2,3,4,5,6]  a[ : 3]表示从索引0取到2（3-1）

也可以a[-2:]表示取最后两位数

字典dict

       在Python中， 字典是一系列键—值对。每个键都与一个值相关联，你可以使用键来访问与之相关联的值,这种key-value存储方式，可以通过key拿到对应的value，也可以在key中存放value,key必须是不可变对象。

列“alien_0 = {'color': 'green', 'points': 5}”

set

      set和dict类似，但只存储key，不存储value,且key不能重复，可以通过add(key)方法对set添加元素，重复添加同样的元素无效

        两个set可以做数学意义上的交集，并集

>>> s1 = set([1, 2, 3])

>>> s2 = set([2, 3, 4])

 >>> s1 & s2

{2, 3}

 >>> s1 | s2

{1, 2, 3, 4}

 

 

语句

if语句

     If-else语句   if-elif-else结构（可多次使用elif和省略else）

使用 break退出循环 

在循环中使用continue退出第一层循环

条件测试语句

while循环语句

     while x:  满足x条件语句就执行y语句

          y

for …. in …语句

 

with语句

 

 

惰性计算

迭代：

     给定一个 list 或 tuple，我们可以通过 for 循环来遍历这个 list 或tuple，这种遍历我们称为迭代（ Iteration）。通过for …. in来完成

通过 collections 模块的 Iterable 类型判断：

from collections import Iterable

>>> isinstance('abc', Iterable) # str 是否可迭代

enumerate 函数可以把一个 list 变成索引-元素对，这样就可以在 for 循环中同时迭代索引和元素本身

for i, value in enumerate(['A', 'B', 'C']):

    默认情况下， dict 迭代的是 key。如果要迭代 value，可以用 for  value in d.values()，如果要同时迭代 key 和 value，可以用 for  k, v in d.items()。

  for magician in magicians:

这行代码让Python获取列表magicians中的第一个，并将其存储到变量magician中

迭代器：

    可以直接用于for循环的对象统称为可迭代对象：Iterable。

可以被next()函数调用并不断返回下一个值的对象为迭代器：Iterator

可以用isinstance()判断一个对象是否是Iterator

>>>from collections import Iterator

>>>isinstance([],Iterator)

>>>False

把 list、 dict、 str 等 Iterable 变成 Iterator 可以使用 iter()函数：

>>> isinstance(iter([]), Iterator)

If语句    if-else语句   if-elif-else结构（可多次使用elif和省略else）

使用 break退出循环 

在循环中使用continue返回到循环开头

条件测试语句

函数

     函数本身可以赋值给变量，函数名也是变量

 用def开头 列

def  greet_user()：
"""显示简单的问候语"""
     print("Hello!")
greet_user()

from … import … as … 语句表示导入某.py文件中的某函数且对该函数改名

函数的返回值用return语句表示

pass语句：什么事也不做的空函数（占位符）

实参和形参

     形参函数完成其工作所需的一项信息。实参是调用函数时传递给函数的信息

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

 

reduce()函数

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

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

filter()函数

     filter()函数用于过滤序列，接收一个函数一个序列，传入的函数依次作用于每个元素，然后根据返回的布尔值决定保留还是丢弃该元素

     def is_odd(n):

return n % 2 == 1

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

# 结果: [1, 5, 9, 15]

sorted()函数

     排序算法。

sorted()函数就可以对list进行从小到大的排列

此外，它还可以接收一个key函数来实现自定义排序

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

[5, 9, -12, -21, 36]

返回函数

函数作为返回值

def lazy_sum(*args):       >>>f = lazy_sum(1, 3, 5, 7, 9)

def sum():         >>> f

ax = 0        >>>f()

            for n in args:   >>>25

 ax = ax + n

return ax

return sum

返回的不是求和结果而是求和函数，调用f才打印求和结果

匿名函数

匿名函数 lambda  x:  x * x 实际上就是：

def  f(x):

return x * x

lambda表示匿名函数，冒号前面的x表示函数参数

匿名函数只能有一个表达式，不用return语句

装饰器

在代码运行期间动态增加功能的方式，称之为装饰器（Decorator）

def  addworld(func):

    def addfun():

       return func() + “world”

    return addfun

@addworld

def printhello():

   return “hello”

print printhello()

@addworld等价于addwold(printhello),意思是@X下面的函数作为X函数的参数（X也可是类）

偏函数

    当函数的参数太多，可以使用functools.partial（偏函数）

创建一个新函数，这个新函数可以固定原函数的部分参数，调用起来跟简单

>>> import functools

>>> int2 = functools.partial(int, base=2)  #把int设置为二进制转换十进制函数

 >>> int2('1000000')

64

>>> int2('1000000', base=10) #也可以在调用时传入其他值

 1000000

 

参数组合：

      位置参数：形参与实参必须一 一对应

默认参数（默认值）：每调用一次默认参数后默认参数的内容就被更新一次

      *args 是可变参数， args 接收的是一个 tuple；

     **kw 是关键字参数， kw 接收的是一个 dict。

     命名关键字参数：限制关键字参数的名字

def  person(*, city, job):  #限制了关键字参数的名字为city和job

     def  f1(a, b=0, *c, *, d, **e):

对于任意函数，都可以通过类似 func(*args, **kw)的形式调用

 

递归函数：

     如果一个函数在内部调用自己本身，这个函数就是递归函数。使用递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出。

列：n!可以这样写

   def fact(n):

      if  n == 1:

          return 1

      return  n * fact(n-1)

    在计算机中，函数调用是通过栈（ stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

模块：

     每一个包目录下面都会有一个__init__.py 的文件，这个文件是必须存在的

用import 打开模块 列 

     import pizza     代码行import pizza让Python打开文件pizza.py，并将其中的所有函数都复制到这个程序中。

     导入module_name.py文件中以function_name命名的函数：

     from module_name  import  function_name

使用 as 给函数指定别名  from  pizza  import  make _pizza  as  mp

上面的 import语句将函数 make_pizza()重命名为 mp()；

类

列class Dog(object)：#所有类最终都会继承的类object

      def  _init_ (self,name,age)

"""初始化属性name和age"""
self.name = name
self.age = age

def sit(self):
"""模拟小狗被命令时蹲下"""
print(self.name.title() + " is now sitting.")

def roll_over(self):
"""模拟小狗被命令时打滚"""
print(self.name.title() + " rolled over!")

以class开头 类的首字母大写，方法__init__()是一个特殊的方法 方法__init__()定义成了包含三个形参： self、 name和age。在这个方法的定义中，形参self必不可少，还必须位于其他形参的前面，调用时不用传达参数。

数据封装

在类的内部定义新的函数，使得数据封装在类中，类中的函数称为方法，比如方法sit（）和roll_over()

继承

   从现有的class继承，新的calss称为子类，被继承的class称为基类，父类或超类

class dog（Dog）:

pass

父类Dog，子类dog，继承最大的好处是可以获得父类的全部功能，且子类可以创建自己新的函数

多态

当子类与父类中含有相同函数时，子类的函数就覆盖了父类的函数

在继承关系中，子类的数据类型也可以被看做是父类

使用@property

     @property装饰器广泛应用在类的定义中，把一个getter方法变成属性，只需要加上@property就行了，另一个装饰器@score.setter，负责把setter方法变成属性赋值，通过getter和setter方法使属性不直接暴露，只定义getter方法，不定义setter就是一个只读属性

     class student(object):

         @property    #getter方法

         def score(self):

            pass

         @score.setter    #setter方法

         def score(self, value):

            pass

         @property

         def age(self):    #只读属性

            pass

多重继承

通过多重继承，一个子类就可以同时获得多个父类的所有功能

class Bat(Mammal, Flyable):

 pass

MixIn

    在定义类的过程中改变类的继承顺序，当某个模块不能修改时，通过MixIn方式可以动态添加该类的方法，动态改变类的原有继承体系

获取对象信息

使用type

判断数据类型

>>> type(123)   #判断基本数据类型

<class 'int'>

>>> type('str')

<class 'str'>

一个变量指向函数或类，也可以用typa()

比较两个变量数据类型是否相同

使用isinstance

判断class的类型可以使用isinstance（），可以判断一个对象是否是该类型本身，或者位于类型的父类继承链接上

使用dir（）

   获取一个对象的所有属性和方法

使用 _slots_

   由于程序运行的过程中可以动态给class加上方法，如果需要给class添加固定属性的方法，可以在定义class时，定义一个_slots_变量

 class Student(object):

__slots__ = ('name', 'age') # 用 tuple 定义允许绑定的属性名称

注意：使用_slots_定义的属性只对当前类起作用，对子类不起作用

定制类

形如_xxx_的变量或函数名在python中是有特殊用途的

_str_和_repr_

这两个方法都用于显示，当我们打印一个对象时显示的是对象的内存地址，我们可以用_str_或_repr_方法改变输出方式，_str_是面向用户的，而_repr_面向程序员

用_repr_方法时，不论直接输出对象还是用print打印的信息都会按照_repr_方法中定义的方式进行显示

用_str_方法时，直接输出对象不会按照_str_方法中定义的格式输出，只有print时才会

_iter_

   因为可直接使用for..in循环就是一个迭代对象，如果一个类被用于for..in循环，就必须用方法_iter_返回一个迭代对象，

for循环就会不断调用该迭代对象的_next_()方法拿到下一个值，如果_iter_方法返回的不是一个迭代对象或for循环结束就会报错

枚举类

python枚举作为一个类存在，使用他需要先导入枚举模块，然后继承并自定义需要的枚举类，导入模块可以是Enum(枚举值可以是任意类型)也可以是IntEnum（枚举值只能是整型）。枚举类的值不可以被外界更改

枚举类不允许存在相同的标签，但是允许不同标签的枚举值相同，这样后者相当于前者的别名，当使用了装饰器@unique后就不能设置别名了

from enum import Enum, unique 

@unique    #不能设置别名

class Weekday(Enum):  #继承Enum类

    sun = 0

 

错误处理

try的用法：

try:

print('try...')

r = 10 / int('2')

print('result:', r)

except ValueError as e:

print('ValueError:', e)

except ZeroDivisionError as e:

print('ZeroDivisionError:', e)

else:

 print('no error!')

finally:

print('finally...')

print('END')

当我们认为某些代码可能出错时，可以用try来运行该代码，try中从上往下执行一旦遇到错误代码就会直接跳入except语句（错误代码）中，并执行except后面为真的语句，如果try没有错误语句就不执行except而执行else语句，但不论怎样finally语句都会被执行，同样finally语句可有可无