python笔记

List：Classmates = [‘Mach’,’Bule’,’Tkua’]      获取长度函数：Len(classmates)

增加元素到末尾：classmates.append(‘Foder’)

插入元素到指定位置（i代表对应位置，value代表对应位置的值）：classmates.insert(i,’value’)

删除末尾的元素和指定位置元素（i代表对应位置）：classmates.pop()  classmates.pop(i)

替换元素，直接赋值给对应位置即可：classmates(i) = ‘value’

List里面也可以有list：s = [‘python’,’java’,’[‘asp’,’php’],’scheme’]，长度为4，如果要取到PHP可以通过s[2][1]取出；或者定义p = [‘asp’,’php’],通过p[1]取出。

tuple: classmates = (‘Mach’,’Bule’,’Tkua’)

另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改，它也没有append()和insert()这样的方法；因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。Python规定只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：t = (1,)

tuple也可以像list一样在里面继续套用list或tuple，但tuble里面的内容不能更改，而list可以更改。

dict：d = {‘michael’: 95, ‘bob’: 75, ‘Tracy’: 85}  #{key：value}

判断key是否存在dict中有两种方法：

1. Key in d #不存在会返回False，存在返回Ture。

2. d.get(key, -1) #-1为指定返回值，如不指定返回值，默认不返回。当key存在时返回dict中的值，当不存在返回指定值。

删除一个key：d.pop(key)

dict特点：

查找和插入的速度极快，不会随着key的增加而变慢；

需要占用大量的内存，内存浪费多。

list特点：

查找和插入的时间随着元素的增加而增加；

占用空间小，浪费内存很少。

set和dict类似，也是一组key的集合，但不存储value：s = {1, 2, 3, 4}

增加元素：s.add(key)

删除元素：s.remove(4)

条件判断if

input()返回的值是str类型，不能直接和整数比较。float() int()

S = input(‘birth:’)

Birth = int(S)

if birth < 2000:

  print(‘00前’)

else：

  print(‘00后’)

for循环和while循环

names = [‘M’, ’N’, ‘B’]

for name in names:

    print(name)

for I in range(100)  # range()函数语法range(start, stop, step), start默认为0，step默认为1，只输入一个参数，该参数代表stop

x = ‘runoob’

for I in range(len(x)):

    print(x[i])

while循环，只要条件满足，就不断循环，条件不满足时退出循环

sum = 0

n = 99

while n > 0:

  sum = sum + n

  n = n – 2

print(sum)

break：在循环中退出循环；continue：直接跳出当前循环开始下一次循环。

函数：

abs(i)  #求绝对值的函数，仅接收一个参数。

max()  #接收任意多个参数，返回最大值。

int()  #把其他类型转换成整数类型，float()，str()等用法相似。

hex()  #将整数转换成十六进制表示的字符串。

math.sqrt(i)  #计算i的平方根函数

定义函数：def  my_abs(x):

              if x >= 0

                  return x

              else:

                  return –x

空函数：def nop():

          pass  # pass作为占位符，不起任何作用。

def power(x, n=2)  #定义函数时对变动较小的参数可设置默认值，默认参数必须指向不变对象。

def calc(*numbers):  #定义参数个数可变的函数，在参数前面加一个*号，numbers接收到的是一个tuple。

def person(name, age, **kw):  #关键字参数，保证接收name和age，其他提供的参数也能接收。

def person(name, age, *, city, job):  #命令关键字参数，只接收city和job作为关键字的参数。命名关键字参数需要一个特殊分隔符*，如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了。

高级特性

切片：L [0:10:3]  #从0开始到10，步数为3； list和tuple及字符串都可以用切片操作。

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

判断一个对象是否可迭代，可以通过collections模块的Iterable类型来判断；

          from collections import Iterable

          isinstance(‘对象’, Iterable)  #对象类型是否可迭代；

      如果要对list实现类似java那样的下标，可以使用enumerate函数把list变成索引-元素对，可以在for循环中同时迭代索引和元素本身。

    Python里面for循环可以同时引用两个变量：for x, y in [(1,1), (2,4), (3,9)]

列表生成式：list(range(1,11))  #生成一个[1,2,…,10]的list；

            [x * x for x in range(1, 11) ]  #生成一个[1,4,9….,100]的list；

            [x * x for x in range(1,11) if x % 2 == 0]  #生成list时可加入条件；

            [m + n for m in ‘ABC’ for n in ‘XYZ’]  #可以使用两层排列；

生成器generator： g = (x * x for in range(10))  #生成器即为将列表生成式的[]改为()，根据循环不断推算后续的元素，不会创建完成的list，从而节省大量的空间；

      我们可以直接打印list的每一个元素，但对于generator的每个元素，可以通过next()函数获取；每次调用next就计算下一个元素（基本上使用for循环迭代），没有更多元素时，抛出stopIteration的错误；

      要把函数变成generator，只需要把print(b)改为yield b即可；

      def fib(max):

        n, a, b = 0, 0, 1

        while n < max:

            yield b

            a, b = b, a+b

            n = n + 1

        return ‘done’

      一般使用for循环调用generator，但拿不到generator的return语句，如果想要拿到返回值，必须捕获stopIteration错误，返回值包含StopIteration的value中：

      g = fib(6)

      while True:  #while True语句中要有结束该循环的break语句，否则会一直循环；

          try:

            x = next(g)

            print(‘g:’, x)

          except StopIteration as e:

            print(‘Generator return value:’, e.value)

            break

迭代器：可以被next()函数调用并不断返回下一个值的对象称为迭代器，可以用isinstance()判断；

        from collections import Iterator

        isinstance([], Iterator)

list、tuple、dict、set、str、generator和带yield的generator function直接作用for循环的对象成为可迭代对象：Iterable；可以使用isinstance()判断；把list、dict、str等Iterabe变成Iterator可以使用iter()函数:

        from collections import Iterable

        isinstance([], Iterable)

函数式编程—高阶函数

map(): map函数接收两个参数，一个函数，一个Iterable，map将传入的函数作用到序列的每一个元素，并将结果作为新的Iterator返回；

    r = map(f, [1, 2, 3, 4])  # r是一个Iterable，需要list函数让它把整个序列都计算出来；

    list(r)

reduce()：把一个函数作用在一个序列上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算；

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

配合map一起使用，可以写出能将str转换成int的函数：

from functools import reduce

def fn(x, y):

return x * 10 + y

def char2num(s):

digits = {‘0’ : 0, ‘1’ : 1, ‘2’ : 2, ‘3’ : 3, ‘4’ : 4, ‘5’ : 5, ‘6’ : 6, ‘7’ : 7, ‘8’ : 8, ‘9’ : 9}

return digits[s]

reduce(fn, map(char2num, ‘13579’))    #运行结果为：13579

filter()：和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是true还是false来决定保留还是丢弃。其结果也是一个Iterator，需要list()函数获取所有结果并返回list；

sorted()：排序函数；它还可以接收一个key函数来实现自定义排序；

sorted([36, 5, -12, 9, -21], key=abs)

sorted([‘bob’, ’Zas’, ‘asw’])  #字符串排序，按照ASCII的大小比较，’Z’ < ‘a’

要进行反向排序，不必改动key函数，可以传入第三个参数reverse=True

Sorted([‘Bob’, ‘Zsd’, ‘ax’], key=abs, reverse=True)

返回函数：

匿名函数：关键字lambda表示匿名函数，冒号前面的x表示函数参数；可以赋值给一个变量，也可以作为返回值；

          list(map(lambda x: x**2, [1, 2, 3, 4, 5, 6]))  #只能有一个表达式，不用写return；

装饰器：假设我们要增强now()函数的功能，在函数调用前后打印日志，但又不希望修改now()函数的定义，这种在代码运行期间动态增加功能的方式，称之为装饰器。使用时需借助@语法：@log  /  @log(‘参数’)

      import functools

      def log(text):

          def decorator(func):          #针对带参数的decorator，不带参数可以省去

              @functools.wraps(func)  #保证函数_name_名不被返回的wrapper更改

              def wrapper(*args, **kw):

                  print(‘%s %s():’ %(text, func._name_))

                  return func(*args, **kw)

              return wrapper

          return decorator

偏函数：int()函数能将字符串转换成整数，当传入字符串，默认按十进制转换，再后增加base参数，可按N进制转换：int(‘1234’, base=8)。但转换大量的就非常麻烦，可以自定义一个int2()，当然可以借助偏函数自己创建int2()，

Import functools

Int2() = functools.partial(int, base=2)  #functools.partial只是把某些参数固定，可更改；

模块：目录下面一定要有一个_init_.py的文件，否则python就把这个目录当成普通目录，而不是一个包。_init_.py可以是空文件，也可以有python代码，因为它本身就是一个模块，模块名为上层目录；

使用模块：

安装第三方模块：Anaconda已内置了很多第三方库，非常简单易用；