Python基础

Python基础

+ 和 * 可以用在字符串上，分别表示拼接和重复

Python中的函数返回多个值的是时候，是打包为元组tuple返回

 

类型判定：

    if not isinstance(n, int):

        print('Factorial is only defined for integers.')

 

操作in：

    in这个词在字符串操作中是一个布尔操作符，它读取两个字符串，如果前者的字符串为后者

所包含，就返回真，否则为假：

    >>> 'a' in 'banana'

True

>>> 'seed' in 'banana'

False

in也可用于其他序列进行判断，但用于map时，判断的是key

 

 

文件读取操作：

 

 

    在 for 循环中也可以使用文件对象。下面的这个程序读取整个 words.txt 文件，然后每行输出

一个词：

    fin = open('words.txt')

for line in fin:

word = line.strip()

print(word)

 

元组和字符串均不可修改。

列表，字符串，元组，均可进行切片操作

列表也可进行拼接操作和重复操作，+和*

 

 

append方法，列表末尾添加元素，参数为一个元素

extend方法，列表末尾添加另一个列表，参数为一个列表

 

 

 

 

map函数：将一个函数作用于一个可迭代对象的所有元素

用法：map(function, iterable, ...)

>>>def square(x) : # 计算平方数

... return x ** 2

...

>>> map(square, [1,2,3,4,5]) # 计算列表各个元素的平方 [1, 4, 9, 16, 25]

>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数

[1, 4, 9, 16, 25]

# 提供了两个列表，对相同位置的列表数据进行相加

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

[3, 7, 11, 15, 19]

 

 

reduce函数：将一个函数作用于一个可迭代对象的所有元素，并将结果累计

        用法：reduce(function, iterable[, initializer])

>>>def add(x, y) : # 两数相加

... return x + y

...

>>> reduce(add, [1,2,3,4,5]) # 计算列表和：1+2+3+4+5

15

>>> reduce(lambda x, y: x+y, [1,2,3,4,5]) # 使用 lambda 匿名函数

15

 

filter函数：用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表

        用法：filter(function, iterable)

def is_odd(n):

return n % 2 == 1

newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

print(newlist)

[1, 3, 5, 7, 9]

 

split方法：用指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串

        用法：str.split(str="", num=string.count(str))，num为切分次数，默认完全切分

str = "Line1-abcdef \nLine2-abc \nLine4-abcd"

print(str.split()) # 以空格为分隔符，包含 \n

print(str.split(' ', 1 )) # 以空格为分隔符，只切分一次，即分隔成两个

['Line1-abcdef', '\nLine2-abc \nLine4-abcd']

 

join方法：用于将序列中的元素以指定的字符连接生成一个新的字符串。

        用法：str.join(sequence)

str = "-"

seq = ("a", "b", "c") # 字符串序列

print(str.join(seq))

a-b-c

 

字典的get方法：接收一个键和一个默认值。如果这个键在字典中存在，get 就会

返回对应的键值；如果不存在，它就会返回这个默认值

 

zip函数：将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

        用法：zip([iterable, ...])

>>>a = [1,2,3]

>>> b = [4,5,6]

>>> c = [4,5,6,7,8]

>>> zipped = zip(a,b) # 打包为元组的列表

[(1, 4), (2, 5), (3, 6)]

>>> zip(a,c) # 元素个数与最短的列表一致

[(1, 4), (2, 5), (3, 6)]

>>> zip(*zipped) # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式

[(1, 2, 3), (4, 5, 6)]

 

 

enumerate函数：将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

        用法：enumerate(sequence, [start=0])

    >>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']

>>> list(enumerate(seasons))

[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

>>> list(enumerate(seasons, start=1)) # 下标从 1 开始

[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

 

 

词典的item方法：以列表返回可遍历的(键, 值) 元组数组。

        用法：dict.items()

dict = {'Google': 'www.google.com', 'Runoob': 'www.runoob.com', 'taobao': 'www.taobao.com'}

print("字典值 : %s" % dict.items())

# 遍历字典列表

for key,values in dict.items():

    print(key,values)

    Google www.google.com

taobao www.taobao.com

Runoob www.runoob.com

 

 

使用zip和dict快速建立字典：

    >>> d = dict(zip('abc', range(3)))

>>> d

{'a': 0, 'c': 2, 'b': 1}

 

 

 

 

Python中的参数：

1. 位置参数：就是平常用的fun(x)这种
2. 默认参数：fun(x=20)
3. 可变参数：fun(*x)
4. 关键字参数：fun(**x)
5. 命名关键字参数：fun(*, city, job)

 

位置参数：

def power(x):

return x * x

对于power(x)函数，参数x就是一个位置参数。

 

默认参数：

def power(x=2):

return x * x

对于power(x)函数，参数x就是一个默认参数，默认值为2

默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！

 

可变参数：

def calc(*numbers):

sum = 0

for n in numbers:

sum = sum + n * n

return sum

定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数。如果已经有一个现成的list或者tuple要作为参数传入，比如要传入myargs，像这样调用即可：calc(*muargs)

 

关键字参数：

关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。和可变参数一样，如果有一个现成的dict要传入，person(**myargs)即可

 

def person(name, age, **kw):

print('name:', name, 'age:', age, 'other:', kw)

 

在调用该函数时，可以只传入必选参数：

>>> person('Michael', 30)

name: Michael age: 30 other: {}

 

也可以传入任意个数的关键字参数：

>>> person('Bob', 35, city='Beijing')

name: Bob age: 35 other: {'city': 'Beijing'}

>>> person('Adam', 45, gender='M', job='Engineer')

name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

 

 

 

 

命名关键字参数：

如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。

def person(name, age, *, city, job):

print(name, age, city, job)

和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

 

调用方式如下：

>>> person('Jack', 24, city='Beijing', job='Engineer')

Jack 24 Beijing Engineer

 

命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错

 

 

 

参数组合：

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用，除了可变参数无法和命名关键字参数混合。

 

但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数/命名关键字参数和关键字参数。

 

def f1(a, b, c=0, *args, **kw):

print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

 

 

def f2(a, b, c=0, *, d, **kw):

print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)