python笔记

python

a-z：97-122

A-Z：65-90

0-9：48-57

中文：#-- coding: UTF-8 --

1.容器形态

1. list清单

   • 有序、有索引值，内容与长度可以变动，要建立串列，可以使用[ ]建立，串行中的每个元素都用逗号。「,」区隔

   • l1=[2,3,4]
     当l2=l1[：]是对l1修改不影响l2

     当l2=l1时对l1修改l2也会被修改

   • 对n进行倒序

   	n=input('n=')
   	print(n[::-1])
   

   • 输出为a

   	list = ["Happy", [2,0,1,5]]
   	print(n_list[0][1])
   

   • append()

     在结尾添加一个项目

   • extend()

     在结尾添加多个项目

   • insert()

   	odd[2:2] = [5, 7]
   	print(odd)
   

   ​ 输出[1, 3, 5, 7, 9]

   • del list[2]    
     print(list)
     删除选定位置的项目
     

   • pop()

     如果未提供索引，则该方法将删除并返回最后一项

   • remove（）
     list = ['p','r','o','b','l','e','m']
     list.remove('p')
     print(list)
     ['r', 'o', 'b', 'l', 'e', 'm']
     删除项目
     

   • reverse（）

     反转列表项目

   • sort（）

     升序排列

   • index（）

     返回第一个匹配项的索引

   • count（）

     返回符合的值的计数

   • pow2 = [2 ** x for x in range(10)]
     print(pow2)
     等同与
     pow2 = []
     for x in range(10):
        pow2.append(2 ** x)
     

   • tuple转list： list(tuple)

   • 列表推导式：lst[i for i range(10)]

2. set集合

   • set（）

   • 无序，元素不重复

   • 创建空集为a=set（）

   • add（）添加一个元素

   • update（）添加多个元素

   • update()`方法可以将tuples，list，string或其他集合作为其参数

   • 删除：discard（）和remove（）

   • discard()项目中不存在项目时，它保持不变。但是remove()`会在这种情况下引发错误。

3. dict字典

   • 文字={‘ 文字 ’：文字，’ 文字’: 文字 }

   • a={}为创造一个空dict

   • 复制字典可以使用copy（）

   • 访问：dict[’ ‘]或dict.get（’ '）

   • 添加：dict[’ ']=‘ ’

   • mark={}.formkeys([’ ‘,’ ‘,’ '],0)

     {’ ‘:0,’ ‘:0,’ ':0}

   • mark={x:x*x for x in range(6)}

     {0:0,1:1,2:4,3:9,4:16,5:25}

   • 判断 print(1 in mark) 返回true或false

   • mark={}

     for i in mark：

     ​ print（mark[i]）

   • dict.keys()

     dict = {'Name': 'Zara', 'Age': 7}
     print "Value : %s" %  dict.keys()
     输出：['Age', 'Name']
     

4. tuple

   • 有序

   • [ ]

   • 只要在某个值的后面加上「,」 即可，或使用()来建立Tuple物件

   • 一旦建立，不能更动其内容

   • 连接 +

   • list转tuple：tuple（list）

   • 解包和拆包

     a=1

     b=2

     c=(a,b)

     e,f=c

2.运算

1. 数值形态

   • **x x次方
   • // 取余

2. 字符串形态

   • +连接字符串
   • *重复字符串

3. 比较

   • == 、 != 是用来比较物件实际的值，状态等是否相等。is 、 is not 用来比较两物件的参考是否相同。

4. 索引切片

   • tiles[5:5]=5 将5插入tiles的tiles[5]处。

   • set是无序集合，索引就没有意义了。因此切片操作符[]不起作用

3.条件

• if

  if 条件：

  ​ 语句

  else：

  ​ 语句

  1. and
  2. or

4.循环

• for

  for 变量 in range（值）

	n=input('n=')
	n=int(n)
	num=[]
	for i in range(3,n+1):
 		for j in range(2,i):
     		if i%j==0:
         	break
 	else:
     	num.append(i)
	print(num)
        

​ 迭代的对象迭代完并为空时，位于else的子句将执行，而如果在for循环中含有break时则直接终止循环，并不会执行else子句。

• while

  while 条件：

  ​ 语句

  else 条件：

  ​ 语句

5.定义

1. def

   • def 函数名（变量，变量）：

     ​ return：

   • 例如输出输入值的平方

     def mj（w）：
     	return w*w
     

2. lambda

   score=int(input('取十位数'))
   point=score//10
   {
       10:lambda:print('100')
       9:lambda:print('90')
       ...   
   }.get(point,lambda:print('低于60'))（）
   

   做为switch使用

3. 二维数组

   [[0 for z in range(m)] for z in range(n)]

6.输出

• print(‘You got’,c,‘km/l on that tank of gas.’,sep=’ ')
• print(‘{ }{ }{ }’).format( , , )
• print（a，b） 打印：a b
• a=’{0:b}’.format((2**16)-1) print:1111111111111111

7.正则表达式

• \d可以匹配一个数字

• \w可以匹配一个字母或数字

• **.**可以匹配任意字符

• \s可以匹配一个空格，**\s+**表示至少有一个空格

• 在正则表达式中，用*表示任意个字符（包括0个），用+表示至少一个字符，用?表示0个或1个字符，用{n}表示n个字符，用{n,m}表示n-m个字符

• 当有特殊字符时要用’\'转义,比如@ @\

• **[0-9a-zA-Z\_]**可以匹配一个数字、字母或者下划线

• **[0-9a-zA-Z\_]+**只要有其中一个就可匹配

• [0-9a-zA-Z\_]{0,19} {，}限制字符长度

• A|B可以匹配A或B，所以(P|p)ython可以匹配’Python’或者’python’。

• ^{**表示行的开头，**}\d表示必须以数字开头。KaTeX parse error: Expected 'EOF', got '\d' at position 8: 表示行的结束，\̲d̲表示必须以数字结束。

• groups()返回一个小组 groups()返回全部小组

8.文件

​ fp = open(‘131.txt’,‘w’)

模式	描述
-	模式 描述

r 以读方式打开文件，可读取文件信息。

w 以写方式打开文件，可向文件写入信息。如文件存在，则清空该文件，再写入新内容

a 以追加模式打开文件（即一打开文件，文件指针自动移到文件末尾），如果文件不存在则创建

r+ 以读写方式打开文件，可对文件进行读和写操作。

w+ 消除文件内容，然后以读写方式打开文件。

a+ 以读写方式打开文件，并把文件指针移到文件尾。

b 以二进制模式打开文件，而不是以文本模式。该模式只对 Windows 或 Dos 有效，类 Unix 的文件是用二进制模式进行操作的。

• file_stat = os.stat("131.txt")查看文件状态

  在import time时                         使用time.localtime(file_stat.st_ctime)可以转为正常时间
  

• read：如果指定了参数 size，就按照该指定长度从文件中读取内容，否则，就读取全文。被读出来的内容，全部塞到一个字符串里面。

• readline：那个可选参数 size 的含义同上。它则是以行为单位返回字符串，也就是每次读一行，依次循环，如果不限定 size，直到最后一个返回的是空字符串，意味着到文件末尾了

• readlines：size 同上。它返回的是以行为单位的列表，即相当于先执行 readline()，得到每一行，然后把这一行的字符串作为列表中的元素塞到一个列表中，最后将此列表返回。

• seek()：指针移动，以字节为单位进行移动。

9.错误和异常

• NameError 表示未找到要求的名称.

• ZeroDivisionError: 除数为0.

• SyntaxError：直译器语法错误，是唯一不是在执行时发生的异常，在编译时有一个不正确的结构。

• IndexError:请求的索引超出序列范围。

• KeyError:请求一個不存在的字典关键字 。

• IOError: 输入/输出错误。

• AttributeError:尝试访问未知的物件属性。

• 异常可以通过 try语句来检测，有try-except 和try-finally两种方式，但两语句互斥的只能使用其中一种。一个try语句可以对应一个或多个except 子句, 但只能对应一个finally 子句, 或是一個
  try-except-finally 符合语句.

• try except 语句还有一个可选的else子句，如果使用这个子句，那么必须放在所有的except子句之后。这个子句将在try子句没有发生任何异常的时候执行。

• raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。

• 可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类，可以直接继承，或者间接继承，例如:

   class MyError(Exception):
  
          def __init__(self, value):
  
              self.value = value
  
          def __str__(self):
  
              return repr(self.value)
  

• 如果一个异常在 try 子句里（或者在except 和 else 子句里）被抛出，而又没有任何的except 把它截住，那么这个异常会在 finally 子句执行后再次被抛出。

• with：with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法:

  with open("myfile.txt") as f:
      for line in f:
         print(line, end="")
  

  以上这段代码执行完毕后，就算在处理过程中出问题了，文件 f 总是会关闭。

10.面向对象

• class Account:
      pass
  
  def deposit()
  def withdraw()
  acct = Account()
  acct.balance = 0
  deposit(acct, 100)
  withdraw(acct, 20)
  class Account:
      def __init__(self, number, name):
          self.balance = 0
  
  	def deposit()
  
  	def withdraw()
  
  acct.deposit(100)
  acct.withdraw(20)     两者结果相等
  

• def __init__(self, name, score):
          self.name = name
          self.score = score
  __init__方法的第一个参数永远是`self`，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到`self`，因为`self`就指向创建的实例本身。
  
  

  __init__为双下划线

11.闭包

• 在一个函数中定义了一个另外一个函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。可以隐藏内部函数的工作细节，只给外部使用者提供一个可以执行的内部函数的引用。

  def callFunc():
      n = 1
      def show():
          print('show: ', n)
      return show
  
  s = callFunc()
  s()
  
  # show() 因为 show 函数定义在 callFunc 内部，所以外部不可见，不能使用
  

• nonlocal：如果在闭包的内部函数中直接使用外部函数的变量时，如果要修改外部变量的值，需要将变量声明为 nonlocal

12.迭代器

• 通过for…in…这类语句迭代读取一条数据供我们使用的对象称之为可迭代对象（Iterable）

• 可迭代对象是提供迭代器帮助对其进行迭代遍历使用

• 可迭代对象是一个具备了__iter__方法的对象，通过__iter__方法获取可迭代对象的迭代器

• 使用next()函数来获取下一条数据。通过迭代器取得下一个位置的值，内部是调用迭代器对象的__next__方法，来取得下一个位置的值

• iter(iterable)函数是把可迭代对象的迭代器取出来，内部是调用可迭代对象的__iter__方法，来取得迭代器的

13.生成器

• 要创建一个生成器，有很多种方法。第一种方法很简单，只要把一个列表生成式的 [ ] 改成 ( )

  # 参考列表生成式
  L=[x*2 for x in range(6)]
  print(L)
  # 把[] 改为() :就是一个简单的列表生成器
  G=(x*2 for x in range(6))
  

•   def fib(n):
    current_index = 0
    num1, num2 = 0, 1
    while current_index < n:
        # print(num1) # 打印斐波那契数列
        """
         1. 假如函数中有yield，则不再是函数，而是生成器
         2. yield 会产生一个断点
         3. 假如yield后面紧接着一个数据，就会把数据返回，
            作为next()函数或者for ...in...迭代出的下一个值
        """
        yield num1
        num1, num2 = num2, num1 + num2
        current_index += 1
  

         将原本在迭代器`__next__`方法中实现的基本逻辑放到一个函数中来实现，但是将打印输出方式换成 yield，此时新定义的函数便不再是函数，而是一个**生成器**了。
  

• yield关键字有两点作用：

  • 保存当前运行状态（断点），然后暂停执行，即将生成器（函数）挂起
  • 将yield关键字后面表达式的值作为返回值返回，此时可以理解为起到了return的作用

• 可以使用next()函数让生成器从断点处继续执行，即唤醒生成器（函数）

14.可变参数

​ 定义可变参数和一个list活tuple参数相比，仅仅在参数前面加了一个*号，在函数内部，参数numbers接收到的是一个tuple，因此函数代码完全不变，调用该函数时，可以传入任意个参数，包括0个参数

	def calc2(``*``numbers):
    	sum=0
    	for n in numbers:
        	sum=sum+n*n
    	return sum
    15.

16.私有属性

• 为了避免属性被设置为 脏数据，更好的保护属性安全，一般的处理方式为

  • 添加一个方法，在方法内部先判断数据的有效性，再赋值属性
  • 将属性定义为 私有属性，避免对象在外部直接操作属性

• 如果在属性名前面加了2个下划线’__’，则表明该属性是私有属性，否则为公有属性

• 私有属性只能在类的内部访问

• __del()__方法

  • 创建对象后，python解释器默认调用__init__()方法；

  • 当删除一个对象时，python解释器也会默认调用一个方法，这个方法为__del__()方法

  • 当有1个变量保存了某个对象的引用时，此对象的引用计数就会加1

  • 当使用del删除变量时，只有当变量指向的对象的所有引用都被删除后，也就是引用计数为0时，才会真删除该对象（释放内存空间），这时才会触发__del__()方法

• 继承

  • class 子类名:(父类名)

  • 重写父类方法:子类再调用该方法将不会执行父类的处理

  • 调用被重写的父类方法:子类重写了父类方法，仍然想执行父类中的方法，则可以在类中使用super（）来调用方法

  • 私有方法、属性，继承问题:父类中的 私有方法、属性，不会被子类继承可以通过调用继承的父类的共有方法，间接的访问父类的私有方法、属性

  • 多继承：class C(A,B):

17.函数

• global

  在模块层面定义的变量（无需global修饰），如果在函数中没有再定义同名变量，可以在函数中当做全局变量使用

• shuffle（）

  shuffle(tile)打乱tile中的数

• tkinter.messagebox.showinfo（）

  在import tkinter和import tkinter.messagebox后可以弹出提示框

• stamp()

  复制当前图形

• ontimer(draw, 100)

  延时

• onscreenclick（）

  识别点击

• turtle.write(s [,font=(“font-name”,font_size,“font_type”)])

  写文本，s为文本内容，font是字体的参数，分别为字体名称，大小和类型；font为可选项，font参数也是可选项

• vector（）

  设定位置

• rotate（）

  旋转角度

• upper()、lower()、capitalize()和title()

  大写和小写字母：a.upper()和a.lower()

  第一个字母转化为大写字母，其余小写：a.capitalize()

  每个单词的第一个字母转化为大写，其余小写 ：a.title()
  

• radians()

  需要import math  将角度转为弧度
  

• isnumeric()

  a='  '        
  
  print(a.isnumeric()) 
  判断a是否为数字，是返回ture，否返回False
  

• Map()

  items = [1, 2, 3, 4, 5]
  squared = list(map(lambda x: x**2, items))
  # Output:
  # [1, 4,9,16,25]
  
  def multiply(x):
  return (x*x)
  def add(x):
  return (x+x)
  funcs = [multiply, add]
  for i in range(5):
  value = list(map(lambda x: x(i), funcs))
  print(value)
  # Output:
  # [0, 0]
  # [1, 2]
  # [4, 4]
  # [9, 6]
  # [16, 8]
  

• Filter()

 	number_list = range(-5, 5)
 	less_than_zero = list(filter(lambda x: x < 0, number_list))
 	print(less_than_zero)
 
 	#Output: [-5, -4, -3, -2, -1]

• reduce

  reduce(函数, 可迭代对象[, 初始函数])
  使用时需要定义
  from functools import reduce 
  
  def add(x,y):
  
  return x+y
  
  retuce(add,[1,2,3]) 计算1+2+3
  retuce(add,[1,2,3]，2) 计算1+2+3+2
  
  reduce（lambda x,y:x+y,[1,2,3]） 用lambda计算1+2+3
  

• import()语句

  import module1, module2,… moduleN 添加多个模块

  from modname import * 添加一个模块的全部内容
  from modname import name，name1.....从模块中导入一个指定的部分到当前命名空间中
  

• dir()函数

  dir() 函数一个排好序的字符串列表，内容是一个模块里定义过的名字

• reload() 函数

  重新导入之前导入过的模块

  reload(module_name)
  

• strip()

  用于移除字符串头尾指定的字符（默认为空格）

• open()

  模式	描述
  r	以读方式打开文件，可读取文件信息。
  w	以写方式打开文件，可向文件写入信息。如文件存在，则清空该文件，再写入新内容
  a	以追加模式打开文件（即一打开文件，文件指针自动移到文件末尾），如果文件不存在则创建
  r+	以读写方式打开文件，可对文件进行读和写操作。
  w+	消除文件内容，然后以读写方式打开文件。
  a+	以读写方式打开文件，并把文件指针移到文件尾。
  b	以二进制模式打开文件，而不是以文本模式。该模式只对 Windows 或 Dos 有效，类 Unix 的文件是用二进制模式进行操作的。

  例：f = open(’130.txt‘,’r‘)

• re.match()

  成功返回Match对象，否则返回None

  re.match(r’^(\d+)(0*)$’, ‘102300’) \d是贪婪匹配，尽可能匹配更多的0

  re.match(r’^(\d+？)(0*)$’, ‘102300’) 加？就为非贪婪匹配，尽可能少匹配0

• re.split(r’[]，’’)

  re.split(r’[需要删除的部分]+’, ‘字符串’) 如\, \s等

• isinstance

  判断可迭代对象 先from collections import Iterable

• yield

  假如函数中有yield，则不再是函数，而是生成器。yield 会产生一个断点，假如yield后面紧接着一个数据，就会把数据返回，

• nonlocal

• send()

  send()函数可以在唤醒的同时向断点处传入一个附加数据

  def gen():
      i = 0
      while i < 5:
          temp = yield i
          print(temp)
          i += 1
  if __name__ == '__main__':
      # 取得生成器对象
      obj = gen()
  # 使用next()唤醒生成器
  print(next(obj))
  print(next(obj))
  # 使用send唤醒生成器 ，在唤醒的同时向断点处传入一个附加数据
  print(obj.send("haha"))
  # 使用next()唤醒生成器
  print(next(obj))
  # 使用send唤醒生成器 ，在唤醒的同时向断点处传入一个附加数据
  print(obj.send("python"))
  ```
  运行结果:
  0
  None
  1
  haha
  2
  None
  3
  python
  4