笔记

变量可以理解为内存中对象的“引用”   》》函数传参 》》类变量和实例变量的使用

动态语言 变量类型不确定 python  / 静态语言 变量在定义时指明类型，赋值时对类型是否匹配进行判断 java c

变量的赋值：a = "ABC"  解释器执行：（1）内存中创建字符串"ABC"（2）内存中创建变量a （3）a指向"ABC"

                      b = "ABC"  解释器执行：（1）内存中创建变量b （2）b指向a所指向的"ABC"，与a无关

数据类型：不可修改【数值、布尔、字符串、元组】可修改【列表、字典（键不可修改）、集合等】

                  集合中元素是可迭代对象 s=set(iterable)，如字符串、列表、元组、字典。a=set（“abc”） 存为{‘a’,'b','c'}，添加单个元素 a.add() 添加多个 a.update()

python 函数的传参 分参数是否是可修改对象。

类变量和实例变量

class Person:
name=[]

p1=Person() 
p2=Person() 
p1.name.append(1)
print(p1.name) # [1] 
print(p2.name) # [1] 
print(Person.name) # [1]

实例方法、静态方法、类方法：

class A(object):
    #实例方法
    def foo(self,x):
        print('foo-',x)
    
    #类方法
    @classmethod
    def class_foo(cls,x):
        print('class-',x)
    #静态方法
    @staticmethod
    def static_foo(x):
        print('static-',x)

a=A()

#实例方法 使用self传递实例 相当于a.foo(a,x) ,只能用实例调用
a.foo(1) #√
A.foo(1) #×
#类方法   使用cls传递类 ，能用 类和实例 调用
a.class_foo(1) #√
A.class_foo(2) #√
#静态方法 不需要传递类或者实例， 能用 类和实例 调用
a.static_foo(4) #√
A.static_foo(4) #√

python自省  运行时知道对象的类型       type（） dir（） hasattr（） getattr() setsattr() isinstance()

type()获取类型

In [27]: type(123)
Out[27]: int

In [28]: type('123')
Out[28]: str

In [29]: type(None)
Out[29]: NoneType

dir（）带参数时获取该对象的方法和属性；不带参数时，返回当前范围内的变量、方法和定义的类型列表

dir('ABC')
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

可以直接对象调用方法   'ABC'.__len__()

isinstance（）判断是否是某种类型 isinstance('a',str)

In [1]: class Myobject(object):
   ...:     def __init__(self):
   ...:         self.x = 9
   ...:     def power(self):
   ...:         return self.x * self.x
   ...:

In [2]: obj = Myobject()

In [3]: obj.power()
Out[3]: 81

In [4]: hasattr(obj, 'x') # 有属性x么？
Out[4]: True

In [5]: hasattr(obj, 'y') # 有属性y么？
Out[5]: False

In [6]: setattr(obj, 'y') # 设置属性必须有三个参数，少了值
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-6-3b0a0f22117d> in <module>()
----> 1 setattr(obj, 'y')

TypeError: setattr expected 3 arguments, got 2

In [7]: setattr(obj, 'y', 100) # 设置属性y的值为100

In [8]: hasattr(obj, 'y') # 有属性y么？
Out[8]: True

In [9]: getattr(obj, 'y') # 获取属性y！
Out[9]: 100

In [10]: obj.y # 获取属性y
Out[10]: 100

In [11]: obj.x # 获取属性x
Out[11]: 9

python 下划线的含义 

前单 ： 该变量或方法仅供内部使用，只作为对程序员的提示；如果是方法名使用前单，该方法不能用 import *导入

后单 ： 避免和关键字产生命名冲突 class_

双前 ： 名称修饰。解释器会更改变量名，避免子类被扩展时冲突，重写等

双前+双后 ： Python保留这种方式用于特殊用途 __init__() ，用户应避免这种命名方式

单下划线 ： 仅仅作为一个名字占位，表示该变量是临时的或者无用的。另外 “_”表示解释器评估的最近一个表达式的结果。

参考 ： https://blog.csdn.net/tcx1992/article/details/80105645

迭代器(iterator)和可迭代对象(iterable)

能用于for循环（集合数据类型 list tuple dict set str）的都是可迭代对象；

能调用next()函数的都是迭代器，迭代器是惰性序列，即只通过next调用，要求返回下一个数据时才会计算

list、str、tuple等都是可迭代对象，不是迭代器，可通过iter([])变为迭代器

可用isinstance判断是否迭代器、可迭代对象。isinstance([],Iterable),isinstance([],Iterator)

生成器（generator）

列表生成式可以直接创建列表，直接全部生成，占用较大的内存空间，且列表的容量一定是有限的，所以，如果列表的元素可以按照某种算法推算出来，在循环时再不断推算，不必创建完整的列表。

一边循环一边计算的机制叫做 生成器。

生成器创建(1) 用()代替生成式中的[] 如 gn = (x*x for x in list)  调用时实际是用gn.next(),但应用中用for循环来简化操作 for c n gn

(2)函数中的print换成yield，包含关键字yield的函数是generator，调用next时执行，遇到yield返回，中止，再次调用nextt执行时从上次中断的yied处继续运行。for n in fib（6）：print n

函数参数：默认参数、可变参数*a、关键字参数**a

默认参数：必选参数在前，默认参数在后；多个参数时，变化大的参数放在前面；在有多个默认参数时，调用时可按照定义顺序提供默认参数，不按顺序时，需要写参数名（city = tj）；默认参数必须指向不变对象。

可变参数：可变参数即传入的参数个数是可变的，0个或多个，在调用时函数内部会把参数组装成tuple，def calc（*num）

，如果想传入的不是单独的参数，而是封装在list或tuple内的参数则在其前面加*即可。n=[1,2,3]，calc

(*num)

关键字参数：与可变参数相同的在于都可以传递0个或多个参数，但关键字参数必须含有参数名；关键字参数在函数内部被封装成一个dict。可用于注册需求的某些可选项。如果参数本来就被封装在dict里，则def calc（**dictname）

参数定义顺序：必选参数、可选参数、可变参数、关键字参数。func(*args,**kw)

AOP aspect orient process 面向切面编程。切面代表的是一个普遍存在的共有功能，如日至切面、权限切面、食物切面等。将业务逻辑代码和共有代码分开存放，维护简单。

装饰器就是为了解决这类事情

引用和copy(),deepcopy()的区别：https://blog.csdn.net/u011630575/article/details/78604226

is 和 ==https://www.cnblogs.com/kiko0o0/p/8135184.html

read readlines readline：

• read 读取整个文件
• readline 读取下一行,使用生成器方法
• readlines 读取整个文件到一个迭代器以供我们遍历

map（函数名，可迭代对象） 把函数作用于可迭代对象的每一个元素上，生成一个迭代器，是惰性序列，因此可以用list（）都求出来。

reduce（函数名，[序列]），函数必须接受两个参数，把结果再和下一个参数送入函数中。

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

python中认为以下值为假 False：False None 0 '' () [] {} 空和0都认为是false

filter（函数名，序列），把函数作用于每一个元素，返回值为true的留下，false的丢掉。也是生成惰性序列

sorted（[序列]，key=函数名，reverse=True）默认是升序排列，reverse为true降序排列。

匿名函数 lambda x输入参数  ： 只有一个表达式，返回值为表达式结果

get 和 post

GET请求会显示请求指定的资源。一般来说GET方法应该只用于数据的读取，请求指定的页面信息，并返回响应主体，GET被认为是不安全的方法。

POST请求会 向指定资源提交数据，请求服务器进行处理，如：表单数据提交、文件上传等，请求数据会被包含在请求体中。POST方法是非幂等的方法，因为这个请求可能会创建新的资源或/和修改现有资源

AJAX,Asynchronous JavaScript and XML（异步的 JavaScript 和 XML）, 是与在不重新加载整个页面的情况下，与服务器交换数据并更新部分网页的技术

http提交请求到响应的过程：https://www.cnblogs.com/xuxinstyle/p/9382506.html

域名解析--发起tcp的三次握手-建立tcp连接后发起http请求--服务器响应http请求，浏览器收到html代码--浏览器解析html代码并请求代码中的资源（js、css、图片等）--浏览器对页面进行渲染呈现给用户。