我的python学习---基础知识汇总

python基础知识汇总

函数与变量

占位符

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

tuple：元组

是一种一旦定义，不可修改的list。

元组：T = ( )

List：列表

列表： L = [ ]

迭代

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

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

for循环其实可以同时使用两个甚至多个变量，比如dict的items()可以同时迭代key和value：

  
  >>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
  >>> for k, v in d.items():
  ...     print(k, '=', v)
  ...
  y = B
  x = A
  z = C

Iterable对象

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

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

函数的可变参数（*args）tuple or list

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

使用可变参数可以直接传入参数

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

  
  >>> calc(1, 3, 5, 7)
  84

不使用可变参数需要传入list

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

  
  >>> calc((1, 3, 5, 7))
  84
  **或者
  >>> nums = [1, 2, 3]
  >>> calc(nums[0], nums[1], nums[2])
  14
  **或者
  >>> nums = [1, 2, 3]
  >>> calc(*nums)
  14

关键字参数（**kw）dict

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

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

可以不传参

  
  >>> person('Michael', 30)
  name: Michael age: 30 other: {}

可以传dict内容

  
  >>> person('Bob', 35, city='Beijing')
  name: Bob age: 35 other: {'city': 'Beijing'}

也可指直接传dict对象，**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。

  
  >>> extra = {'city': 'Beijing', 'job': 'Engineer'}
  >>> person('Jack', 24, **extra)
  name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

命名关键字参数，例如：只接收city和job作为关键字参数。

和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

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

  
  >>> person('Jack', 24, city='Beijing', job='Engineer')
  Jack 24 Beijing Engineer

匿名函数

python中使用 lambda**关键字来创建匿名函数**

语法格式：

lambda [参数1 [,参数2,..参数n]]:表达式

**lambda **参数列表：return[表达式] 变量

由于lambda返回的是函数对象（构建的是一个函数对象），所以需要定义一个变量去接收

  
  # news_add = a + b
  news_add = lambda a, b: a + b

递归

  
  def fact(n):
      if n==1:
          return 1
      return n * fact(n - 1)

  
  ===> fact(5)
  ===> 5 * fact(4)
  ===> 5 * (4 * fact(3))
  ===> 5 * (4 * (3 * fact(2)))
  ===> 5 * (4 * (3 * (2 * fact(1))))
  ===> 5 * (4 * (3 * (2 * 1)))
  ===> 5 * (4 * (3 * 2))
  ===> 5 * (4 * 6)
  ===> 5 * 24
  ===> 120

尾递归（python未对其优化，和递归所占内存差别不大）

  def fact(n):
      return fact_iter(n, 1)
  ​
  def fact_iter(num, product):
      if num == 1:
          return product
      return fact_iter(num - 1, num * product)

  
  ===> fact_iter(5, 1)
  ===> fact_iter(4, 5)
  ===> fact_iter(3, 20)
  ===> fact_iter(2, 60)
  ===> fact_iter(1, 120)
  ===> 120

python高级特性

生成器 generator

要创建一个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))
  >>> g
   at 0x1022ef630>

迭代器 Iterator

一类是集合数据类型，如list、tuple、dict、set、str等；

一类是generator，包括生成器和带yield的generator function。

凡是可作用于for循环的对象都是Iterable类型；

凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

面向对象

闭包

  
  def count():
      fs = []
      for i in range(1, 4):
          def f():
               return i*i
          fs.append(f)
      return fs
  ​
  f1, f2, f3 = count()

  
  >>> f1()
  9
  >>> f2()
  9
  >>> f3()
  9
  ​

返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

  
  def count():
      def f(j):
          def g():
              return j*j
          return g
      fs = []
      for i in range(1, 4):
          fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
      return fs

  
  >>> f1, f2, f3 = count()
  >>> f1()
  1
  >>> f2()
  4
  >>> f3()
  9
  ​

创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变。

访问限制

设置私有变量，只能通过内部函数调用

  
  class Student(object):
  ​
      def __init__(self, name, score):
          self.__name = name
          self.__score = score
  ​
      def print_score(self):
          print('%s: %s' % (self.__name, self.__score))

判断对象类型

优先使用isinstance()判断类型，可以将指定类型及其子类“一网打尽

  
  >>> isinstance(h, Animal)
  True

实例属性和类属性

  
  >>> class Student(object):
  ...     name = 'Student'
  >>> s.name = 'Michael' # 给实例绑定name属性
  >>> print(s.name) # 由于实例属性优先级比类属性高，因此，它会屏蔽掉类的name属性
  Michael
  >>> print(Student.name) # 但是类属性并未消失，用Student.name仍然可以访问
  Student

文件操作

文件读取方式

方式一

  
  with open('/path/to/file', 'r') as f:
      print(f.read())

方式二

  
  >>> f = open('/Users/michael/test.txt', 'r')
  >>> f.read()
  >>> f.close()

JSON

JSON类型	Python类型
{}	dict
[]	list
"string"	str
1234.56	int或float
true/false	True/False
null	None

常用模块

Pillow （Python Imaging Library）

  
  $ pip install pillow

  
  from PIL import Image

END