Python-BasicLine

心想：

为了抗拒遗忘，方便之后的回顾复习，整理了一些Python中很简单基础的命令。

【Python，一切皆对象】

1、a , b = b, a  # 同时将右边的数据赋值给左边

2、string类型变为list，每个元素仍为string

3、map函数和列表生成器的函数写前面，map后面跟的是Iterable，列表生成器后面跟的是for循环、if判断等，相当于也有filter的一部分功效

4、数组是指 list, tuple, set，字符串指string

• list [ ]    

list(iterable) 类型的都支持强制类型转换

append()    # 没有返回值

pop()    # 返回值是取出的那个元素，原列表相应的会删掉这个元素

list.insert(index, obj)    # 插入，没有返回值

len

list.extend(list)    # 合并两个list

list.index(' ')    #查找某个字符出现的首个位置

string.split()    # 根据空格拆分字符串

• tuple ()

• dict { 键key : 值value }

键是字符串类型的，字符串单引号和双引号是类似的

dict的存储顺序是凌乱的！因此不能根据位置来提取values

dict.keys()    dict.values()    dict.items()

key in Iterable# 判断key是否在字典里

key not in Iterable

dict.get(keys)

dict.pop()    # 只会返回

dict[key] = values    # 添加

• set只包含key值（set无序存储，且元素不重复，有去重功能）

xx = set( [...] )

xx.add

xx.remove(item)    # 删除item，没有则引发异常

xx.discard(item)    # 删除item

xx1 & xx2

xx1 | xx2

• string

string是不可以做修改复制操作的，但可以使用切片

string = string[:13] + 'r' + string[14:]    # 字符串链接

print( string_1 + str( int ) +string_2) ==> print('string_1 %s string_2' % (int))        # 格式化字符

• if ... elif ... else
• for ... in ... 
• while ...

• input

格式；返回类型

---

---

函数

• 调用某个函数前需要，form 文件名 import 函数名

• isinstance

• 函数的形参可以赋初值，要善用无类型None

def add_end(L=None):

                L.append('end')

                return L

• 带*的形参表示tuple可变参数，带**的形参表示dict关键字参数

如果*后面是一个list或tuple，则会拆解为一个一个可变参数作为实参传入函数

形参中的*表示组装，把可变参数组装为tuple

• 切片

一个冒号，两个冒号

str[begin:end:step]    #step>0时，begin必须在end左边；step<0，begin必须在end右边，

只有默认（也就是不写的时候）为左闭右闭区间，其他的为左闭右开区间

• Iterable类型，判断是否某个变量是否可以迭代

from collections import Iterable

• for i , value in enumerate( list )  # 对list的元素进行编号

• 列表生成式

[ 显示的内容 for xx in yy ]

[ 显示的内容 for xx in yy   for zz in tt   for ii in dd]

• Iterable与str互转

xx = list(yy)

yy = ''.join(xx)    注意顺序，传入的是一个list# 单引号中是字符之间的分隔符，如','  ';' '\t'

• 生成器（是一种惰性序列）

保存的是算法，当需要的时候产生数据

range(xx , yy)    # 包含xx，但不包含yy

1、等号方式

g = ( x+x for x in range(aa))

next(g)

2、函数方式

def g(aa):

        n , x  = 0 , 0 

        b = list(range(aa))

        while n < len( b ):

                x, n= x+b[n], n+1

                yield x+x

        return 'done'

#@@ 惰性序列的好处一方面是不占有内存，另一方面可以自由规定的个数

• 迭代器

1、list    tuple    dict    set    str

2、生成器

---

---

• 变量可以指向函数；函数名也是变量；函数名可以作为形参

• map( f, list )    # f对list中的每一个元素进行运算，第二个位置只要是Iterables就可以

            f函数的形参只能有一个，且是list的一个元素

• reduce( f, list )    # 类似于递归，可以求和之类的

            f函数的形参有两个，且时list的元素

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

（Python3.X已经将reduce从全局命名空间中移除了，from functools import reduce）

• filter与map类似

1）惰性序列

2）根据函数返回值的bool类型判断是否保留这个元素

• Python的Flase value有哪些

None    Flase    0 () [] {}

• And和or的用法

x and y    # x对，返回y；x错，返回x

x or y       # x对，返回x；x错，返回y

不叫括号的情况下，and的优先级大于or

• str.strip(' ')

删除字符串首尾规定的字符

• sorted( Iterable , key = 函数名, reverse = True )

• 匿名函数（返回的是一个函数，需要赋给一个变量函数指针）

lambda 输入参数 : 公式

也可以作为函数的返回值

• 闭包：函数内包含子函数

闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另外一个函数。

• 装饰器decorator    （有点像继承）

目的：对已有的函数添加额外的功能

最后一个return返回的是一个函数指针

#@@ 一个完整的decorator写法

import functools

def log(text):

        def decorator (func):    # 使老函数指向新函数（因此传入的是函数，返回的是另一个参数）

                @functools.wraps(func):            # 保证now函数的 __name__ 不会变为wrapper

                def wrapper (*args, **kw):    # 新函数：包含新加的功能和老函数的功能

                        print('%s %s()' % (text, func.__name__))

                        return func(*args, **kw)        # 注意return，这里return的是一个有传入参数的函数，相当于执行了

                return wapper                                # 这里return的仅仅是一个函数名，意思是now

        return decorator

@log('这是一个可以传入参数的decorator')

def now():

        print('2017-12-2')

• functools.partial

目的：把一个函数的传入参数固定位一个值，并返回一个新的函数，起到简化函数的作用

• if __name__ = '__main__':

                test()

目的：便于自己做测试

在cmd 中直接运行.py文件,则__name__的值是'__main__';

而在import 一个.py文件后,__name__的值就不是'__main__'了;

• 一个标准的Python代码

• 类

class 类名(object):

        def __init__(self, 形参1，形参2)：

                self.__形参1 = 形参1

                self.__形参2 = 形参2

        def my_function(self):

                xx = 99

                print(xx)    # 局部变量是可以这个调用的

                print(self.__形参1)    # 如果是全局变量，必须以 self. 的方式进行调用

• 下划线

1. 变量名类似__xx__的，是特殊变量，可以直接访问，不是private变量，自己尽量不要这么定义
2. 以一个下划线开头的实例变量名，比如_name，这样的实例变量外部是可以访问的，但是，意思是：虽然我可以被访问，但是，请把我视为私有变量，不要随意访问。
3. 双下滑线开的实例变量其实也是可以访问的，之前不能访问的原因是Python解释器自动把__name改为了_Students__name，只能通过类中内置的传参函数进行修改和访问。

• 类中的self

1、只有在定义类的时候，其中的函数才需要传入self，函数默认第一个传入的都是类的实例对象，也可以不用self这个名字

2、C++不用管这些事情，感觉是因为C++中创建一个实例对象时会立刻复制一份类中所有的内容针对这个实例，更像是结构体；

而Python中则不会，所有实例共用一套类的代码，调用函数的时候会（默认的）传入自己的实例对象。

• 一个类的属性

hasattr( object, name)    # 这里的name指实例object所属类是否 的变量或方法名字

getattr( object, name)

setattr( object, name, values)

• heapq 堆

堆是一种特殊的树形数据结构，每个节点都有一个值，通常我们所说的堆的数据结构指的是二叉树。堆的特点是根节点的值最小（或者最大），而且根节点的两个孩子也能与孩子节点组成子树，亦然称之为堆。

• import heapq

xx = [ ]    # 注意heapq只是一个存储形式，类型仍然是list

heapq.heappush(xx, item)    # 插入

heapq[0]    # 查看当前堆中最小的数

yy = heapq.heappop(xx)    # pop出堆顶，也就是自小的数

heapq.heappushpop(xx, yy)    # pop出堆顶，并插入yy

• import random

random.randint(xx, yy)        # 从xx和yy之间随机选取一个整数

random.choice(Interable)        # 从Iterable变量中随机选取一个元素