Pyhton基础学习笔记

1、数据类型

global

• 在python的函数中和全局同名的变量，如果你有修改变量的值就会变成局部变量，如果确定要引用全局变量，并且要对它修改，必须加上global关键字。

复数

data = 1+2j
print(type(data))    # 复数数据类型

List(有序集合)

• List 中可存放不同的数据类型；

lis = ['a', 'b', 'c']
len(lis)
lis[0]
lis[-1]
lis.append('d')
lis.insert(index, value)
lis.pop()    # delete the last one
lis.pop(index)     
lis.sort()

tuple(元组)

• 一旦初始化，不能修改；
• tuple的每个元素，指向永远不变；

tup1 = ('a', 'b' ,'c')
tup2 = (1,)    # only one value

dict(字典)

• 在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度；
• dict的key必须是不可变对象，dict根据key来计算value的存储位置（Hash）；

d = {
   'a':1, 'b':2 ,'c':3}
d['a']
'd' in d    # false
d.get('d', -1)    # return -1
d.pop('a')    # delete

set

• 一组key的集合，不存储value值，元素不能重复；
• 要创建一个set，需要提供一个list作为输入集合；
• 不可放入可变对象；

s1 = set([1,2,3])
ss = set([1,2,2,2,3])    # {1,2,3},重复元素自动过滤
s1.add(4)
s1.remove(4)
s2 = set([2,3,4,5])
s1&s2
s1 | s2

---

2、函数

abs(-1)    # 1
int('1234')
int(12.34)    # 12
float(12.34)    # 12.34
str(1.23)    # '1.23'
bool(1)     # True
bool('')    # False

属性

• __name__：得到函数的名字

定义函数

• 定义默认参数要牢记一点：默认参数必须指向不变对象！

# 错误定义方式
def add_end(L=[]):
    L.append('END')
    return L

add_end()    # ['END']
add_end()    # ['END', 'END']     ==>  error
# Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。

# 正确的定义方式
def add_end(L=None):
    if L is None:
        L = []
    L.append('END')
    retrun L

# 现在无论调用多少次，都没有问题

• 可变参数

def calc(*nums):    # nums 接收到一个tuple
    sum = 0
    for n in nums:
        sum = sum + n*n
    return sum

calc(1,2)
nums = [1,2,3]
calc(*nums)    # 把list或tuple的元素变成可变参数传进去

• 关键字参数

def person(name, age, **kw):    # kw 接收到一个dict
    pass

person('a', 12, city='Shanghai')
extra = {
   'city':'Beijing', 'job':'Engineer'}
person('b', 13, **extra)

• 命名关键字参数

def person(name, age, *, city='Beijing', job):
    pass

person('a', 22, city='Shanghai', job='Engineer')

# 如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不用加‘*’了
def person(name, age, *args, city, job):
    pass

• 参数顺序：必选参数、默认参数、可变参数、命名关键字参数和关键字参数

3、特性

切片

• list or tuple

L = ['a', 'b', 'c', 'd', 'e']
L[:3]    # ['a', 'b', 'c']
L[1:3]    # ['b', 'c']
L[-2:]    # ['d', 'e']
L[-2:-1]    # ['d']
L[::3]    # 每3个取一个，['a', 'd']

迭代(Iteration)

• dict 的迭代

d = {
   'a':1, 'b':2 ,'c':3}
for key in d:    # 迭代key
    print(key)

for value in d.values():    # 迭代value
    pass

for k, v in d.items():    # 同时迭代key 和 value
    pass

• 判断可迭代对象

from collections import Iterable
isinstance('abc', Interable)    # True
isinstance([1,2,3], Interable)    # True
isinstance(123, Interable)     # False

• enumerate,将一个list变成索引-元素对

for i, value in enumerate(['A', 'B', 'C']):
    print(i, value)

列表生成式(List Comprehensions)

• 受内存的限制，列表的大小也受限；

[x * x for x in range(1, 11) if x % 2 == 0]    # [4, 16, 36, 64, 100]
[m+n for m in 'ABC' for n in 'XYZ']    # ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

# 获取当前目录下的所有文件名和目录
import os
[d for d in os.listdir('.')]

dic = {
   'a':1,'d':2,'A':4,'g':8}
[k + '=' + v for k,v in dic.items()]

L = ['Hello', 'Bye', 122]
[s.lower() for s in L if isinstance(s