python

2019-09-10-python

python

注释：
单行#comment 多行'''comment''' """comment"""

python2 -m pip install --upgrade pip  
pip install virtualenv virtualenvwrapper  
virtualenv testvir  
active.bat 或者 deactive.bat  
pip install flask  
pip freeze >requirements.txt  

基础语法

from package import module  
import module as alias

变量和数据类型

对象（object）是内存中专门用来存储数据的一块区域，id && type && value

变量和对象：

(1)对象并没有直接存储到变量中，Python中变量更像是给对象起了一个别名；

(2)变量中存储的不是对象的值，而是对象的id（内存地址），使用变量时，实际上就是在通过对象id在查找对象；

(3)变量中保存的对象，只有在为变量重新赋值时才会改变；

(4)变量和变量之间是相互独立的，修改一个变量不会影响另一个变量

python中的数据类型: 不可变(Number/String/Tuple) 和 可变(list/dict/set)，不可变值得是不允许变量的值发生变化，如果改变变量的值，相当于新建了一个对象，而对于相同值的对象，在内存中只有一个对象。

如果改变数字数据类型的值，意味着是一个新的对象，将会重新分配内存空间

判断是否引用的是同一个对象: x is y,类似于id(x)===id(y)

数据类型

• 整数、浮点数(1.23x10^9: 1.23e9)

• 字符串

  'abc', "xyz"         >> abc xyz
  'I\'m\"OK\"!'        >> I'm OK！
  r'\\\t\\'            >> '\\\t\\'  # 原始字符串r
  r'''hello,\nworld''' >> 'hello,\\nworld'

• 布尔值

  and: ture and flase  >> false
  or:  false or true   >> true
  not: not false       >> true

变量

变量名必须是大小写英文、数字和_的组合，且不能用数字开头, Python支持多种数据类型，在计算机内部，可以把任何数据都看成一个“对象”，而变量就是在程序中用来指向这些数据对象的，对变量赋值就是把数据和变量给关联起来.

# -*- coding: utf-8 -*-
a = 'ABC'	# 内存中创建'ABC'字符串
b = a		# 内存创建变量b指向'ABC'
a = 'XYZ'   # 创建'XYZ', 将a指向此字符串
print(b)

>> ABC

字符串和编码

Python 3版本中，字符串是以Unicode编码

ord('中')  >> 20013
chr(25991) >> '文'

'中文'.encode('utf-8')
>> b'\xe4\xb8\xad\xe6\x96\x87'

b'\xe4\xb8\xad\xff'.decode('utf-8', errors='ignore')
>> '中'

len(b'ABC')  >> 3	# 字节
len('中文'.encode('utf-8'))  >> 6

格式化输出(%)

• %s %d %?

  'Hello, %s' % 'world'	    >> 'Hello, world'
  print('%2d-%02d' % (3, 1))  >> 补空格3-01
  print('%.2f' % 3.1415926)   >> 3.14

• format()

  'Hello, {0}, 成绩提升了{1:.1f}%'.format('小明', 17.125)  >> 'Hello, 小明, 成绩提升了17.1%' 

• 格式化字符串

  • 格式化字符串，可以通过在字符串前添加一个f来创建一个格式化字符串
  • 在格式化字符串中可以直接嵌入变量

    c = f'hello {a} {b}' \ print(f'a = {a}')

list tuple dict set

list[]

Python内置的数据类型列表：list是一种有序的集合，可以随时添加和删除其中的元素

方法	说明
list.append()	追加元素到末尾
list.insert()	插入到指定位置
list.pop()方法	删除指定位置元素
list.len()	列表元素个数

classmates = ['Michael', 'Bob', 'Tracy']  >> ['Michael', 'Bob', 'Tracy']
len(classmates)  >> 3	
classmates[-1]   >> 'Tracy'
classmates[-2]   >> 'Bob'
classmates.append('Adam')	  >> ['Michael', 'Bob', 'Tracy', 'Adam']
classmates.insert(1, 'Jack')  >> ['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
classmates.pop(3)	          >> 'Tracy' -->['Michael', 'Jack', 'Bob', 'Adam']
classmates[1] = 'Sarah'       >> ['Michael', 'Sarah', 'Tracy']

L = ['Apple', 123, True]
s = ['python', 'java', ['asp', 'php'], 'scheme']

tuple()

Python内置的数据类型有序列表叫元组：tuple，tuple和list非常类似，但是tuple一旦初始化就不能修改

classmates = ('Michael', 'Bob', 'Tracy')
t = ('a', 'b', ['X', 'Y'])
>> t[2][0] = 'X'
>> t[2][1] = 'Y'

dict{}

字典的键可以是任意的不可变对象(int, str, bool, tuple…), 不能重复；字典的值可以是任何对象
{key1:value1,key2:value2,…}

d = dict(name='Li',age='1',gender='boy')
d = dict([('name','Li'),('age','1')])
d = {'name': 'Li', 'age': 1, 'gender': 'boy'}

d['name']	>> Li
d['name'] = "Xing"				# 修改
d.get('name', default)	>> Li 	# key存在返回对应值，不存在返回默认值
d.pop('name')	>> 删除name对应的值

for k in d.keys():	# keys()  返回序列，保存由字典所有键
	print(k,d[k])

>> name Li
   age 1
   gender by

for v in d.values():  # values()  返回序列，保存由字典所有值
	print(v)

for k,v in d.items():	 # items()	 dict_item([('name','Li'), ('age', '1'), ('gender', 'boy')])
	print(k , '=' , v)

>> name = Li
   age = 18
   gender = boy

set{}

集合中只能存储不可变对象，不重复且无序; 将字典转为集合只包含字典中键
对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的

s = {'a', 'b', '1,' '2', '3'}  >> {'a', 'b', 1, 2, 3}
s = set([1, 2, 3, 1, 4])	>> {1, 2, 3, 4}
s.add(5)
s.remove(4)

条件判断&&循环(注意缩进)

# 判断水仙花数(n>=3)
i = 100
while i < 1000:
	bai = i // 100
	# shi = (i -a * 100) // 10
	shi = i // 10 % 10
	ge = i % 10
	if bai**3 + shi**3 + ge**3 == i:
		print(i)
	i += 1
----------------------------------------
# 判断质数(只能被1和它自身整除)
from time import *
begin = time()
num = int(input('输入大于1的整数：'))
i = 2 
while i <= num: # 取出 2-num 所有数
	flag = True # 
	j = 2
	while j <= i ** 0.5:
		if i % j == 0:	# num不是质数 
		flag = False
		break
		j += 1
if flag:
	# pass
	print(i)
i += 1
end = time()
print("use time=",end - begin, '秒')
----------------------------------------------
# 99乘法表(嵌套)
i = 0
while i < 9:
	i += 1	# 外层高度
	while j < i:	# 内层宽度
		j += 1
		print(f"{j}*{i}={i*j} ", end="")
	print()		
----------------------------------------------	
# break && continue(对就近循环起作用)
i = 0 							
while i < 5:
	i += 1
	if i == 2:	
		break	# 结束整个循环
		continue # 结束当次循环
	print(i)
	i += 1
else:
	print('循环结束')
---------------------------------------------
names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

迭代器：iter和生成器：yield

迭代器是访问集合元素的一种方式，是可以记住遍历的位置的对象，从集合第一个元素开始到所有元素被访问完结束，只能往前不会后退；基本方法iter()和next()，字符串、列表和元组均可用于创建迭代器

生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器，调用一个生成器函数，返回的是一个迭代器对象，在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

import sys
def fibonaci(n,w=0):		# 生成器函数:斐波那契
    a, b, counter = 0, 1, 0
    while True:
    	if(counter >n):
    		return 
    	yield a
    	a, b = b, a + b
    	print('%d,%d' % (a,b))
    	counter +=1

f = fibonaci(3,0) 		# f 是一个迭代器，由生成器返回生成
while True:
	try:
		print(next(f), enf=" ")
	except:
		sys.exit()
------------
Output:
0 1,1
1 1,2
1 2,3
2 3,5

函数

概念

• 函数是一个对象，在内存中专门用来存储数据的一块区域；如果形参执行的是一个对象，当通过形参去改对象时，会影响到所有指向该对象的变量；print(fn)，fn是函数对象，实际是打印函数对象；而print(fn())，则是在打印fn()函数的返回值
• 定义:

  def functionName(argu1, argu2, ...):
    code block

函数的参数:

• 位置参数，调用函数时，传入的两个值按照位置顺序依次赋给参数x和n

  def power(x,n):
    s = 1
    while n > 0:
    	n = n -1
    	s = s * x
    return s

• 默认参数，必须指向不变对象

  def add_end(L=None):
    if L is None:
       L = []
       L.append('END')
    return L

• 可变参数，允许传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple

  def calc(*numbers):	# *nums表示把nums这个list的所有元素作为可变参数传进去
    sum = 0
    for n in numbers:
      sum = sum + n * n
    return sum
  >>> nums = [1, 2, 3]
  >>> calc(*nums)
      14

• 关键字参数，允许传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict

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

递归：

def factorial(n):
'''
求任意数的阶乘
参数: 
n: 要求阶乘的数字
'''
  if n == 1:
    return 1
    return n * factorial(n-1)
------------------------------
def huiWen(s):
'''
判断是否为回文字符串
参数：
s：要检查的字符串
'''
if len(s) == 2:
  return False
elif s[0] != s[-1]:
  return False
return huiWen(s[1:-1])

filter、匿名函数: lambda 与 map

• filter(function,iterable): 可以从序列中过滤出符合条件的元素，保存到一个新的序列对象中，

  a = filter(lambda x: x % 2 == 0, range(10))
  >>> <filter object at 0x0000027939040390>

• lambda 参数列表 : 返回值:

  filter(lambda i:i>5,l)

• map(function, iterable, ...): 可以对可迭代对象中的所有元素做指定操作，然后将其添加到一个新的对象中返回，

  map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) 
  >>> <map object at 0x0000027939040CF8>

闭包：函数嵌套 && 将内部函数作为返回值返回 && 内部函数必须使用到外部函数的变量

def makeAverager():
  nums = []
def averager(n):
  nums.append(n)
  return sum(nums)/len(nums)
return averager

averager = makeAverager()

装饰器: 在不改变函数代码的情况下，扩展函数功能

def log(old):
  def wrapper(*args, **kw):
    print('call %s():' % func.__name__)
    return func(*args, **kw)
return wrapper

@log	# now = log(now)
def now():
  print('2015-3-25')

>>> now()
  call now():
  2015-3-25

面向对象编程

基础

• 类：对对象的抽象，是创建对象的模板；属性&&方法

• 对象：则是由类创建的一个实例，而变量是指向对象的内容，如：a='abc'，经常说的对象a的内容是’abc’，其实是指，a本身是一个变量，它指向的对象的内容才是’abc’

• 定义类: p1 = Person('an')执行流程

  • (1)创建一个变量；
  • (2)在内存中创建新对象；
  • (3)__init__(self)方法执行，init在对象创建以后执行，用来初始化新创建的对象
  • (4)将对象的id赋值给变量
  • (5)self指的是类实例对象本身(注意：不是类本身)
  • self参考

     class Person:
       def __init__(self, name):	# 在对象初始化时执行
         self.name = name		    # self为调用该属性/方法实例对象自身 
      # self.__name = name	    # 隐藏属性 __name ==> _Person__name
    def sayHello(self):
      print('我是：%s' %self.name)
    def get_name(self):
      # print('读取属性')
      return self.name
    def set_name(self, name):
         # print('设置属性')
      return self.name = name
    	
    p1 = Person('an')

特征：

• 封装:隐藏对象中一些不希望被外部所访问到的属性或方法，确保对象中的数据安全

  • getter 获取对象中的指定属性（get_属性名）
  • setter 用来设置对象的指定属性（set_属性名）

    class Person:
      def __init__(self,name):
        self._name = name
      def get_name(self):
        return self._name
    
      def set_name(self , name):
        self._name = name   
    
     p = Person('孙悟空')
     print(p._name)

• 继承：实现子类的属性和方法的功能扩展，保证了对象的可扩展性

   class Animal:
     def run(self):
       print('动物会跑~~~')
     def sleep(self):
       print('动物睡觉~~~')
     @property
     def name(self):
       return self._name
     @name.setter    
     def name(self,name):
       self._name = name
  
   class Dog(Animal):
     def __init__(self,name,age):
         # 调用父类的__init__来初始化父类中定义的属性
         # super() 可以用来获取当前类的父类，
         # 并且通过super()返回对象调用父类方法时，不需要传递self
       super().__init__(name)
       self._age = age
     def bark(self):
       print('汪汪汪~~~') 
     def run(self):
       print('狗跑~~~~') 
     @property
  def age(self):
    return self._age
  @age.setter    
  def age(self,age):
    self._age = name
  		
   d = Dog('旺财',18) 
   print(d.name)       
   print(d.age)

• 多态：一个对象可以以不同的形态去呈现，保证了程序的灵活性

模块(python文件) 包(文件)

• 导入模块:

  import 模块名 
  import 模块名 as 模块别名

• 访问模块变量：模块名.变量名
• 导入模块部分内容:

  from 模块名 import 变量 as 别名

异常

print('异常出现前')
l = []
try:
  print(10/0)
except NameError:
  # 如果except后不跟任何的内容，则此时它会捕获到所有的异常
  # 如果在except后跟着一个异常的类型，那么此时它只会捕获该类型的异常
  print('出现 NameError 异常')
except ZeroDivisionError:
  print('出现 ZeroDivisionError 异常')
except IndexError:
  print('出现 IndexError 异常')

# Exception 是所有异常类的父类，所以如果except后跟的是Exception，他也会捕获到所有的异常
# 可以在异常类后边跟着一个 as xx 此时xx就是异常对象
except Exception as e :
  print('未知异常',e,type(e))
finally :
  print('无论是否出现异常，该子句都会执行')

print('异常出现后')
----------------------------------------------------------------------------------
# 自定义异常类，创建一个类继承Exception
class MyError(Exception):
  pass

def add(a,b):
# 如果a和b中有负数，就向调用处抛出异常
  if a < 0 or b < 0:
  # raise用于向外部抛出异常，后边可以跟一个异常类，或异常类的实例
  # raise Exception    
  # 抛出异常的目的
  # raise Exception('两个参数中不能有负数！')  
  raise MyError('自定义的异常')
			
  # 也可以通过if else来代替异常的处理
  # return None
  r = a + b
  return r

print(add(-123,456))

文件

文件打开 –>操作文件(读/写) –>关闭文件

file_name = 'demo.txt'
file_obj = open(file_name)	
content = file_obj.read()
file_obj.close()

# with ... as 语句
# with open(file_name) as file_obj :
# 在with语句中可以直接使用file_obj来做文件操作
# 此时这个文件只能在with中使用，一旦with结束则文件会自动close()
# print(file_obj.read())

file_name = 'demo.txt'
try: 
  with open(file_name,encoding='utf-8') as file_obj:
    file_content = ''
    chunk = 100
    while True:
      content = file_obj.read(chunk)
      if not content:
        break
      # print(content,end='')
      file_content += content

except FileNotFoundError :
  print(f'{file_name} 这个文件不存在！')
print(file_content)