Python之路第三天，基础(3)-set，函数，内置函数，文件，三元运算，lambda

set集合

集合是一个无序的,不重复的元素集合。

集合的创建：

name_set = {'tom','jerry','alex','rose'}
或
name_set = set(['tom','jerry','alex','rose'])

集合的方法：

添加一个元素

def add(self, *args, **kwargs):

name_set.add('jack')

name_set

{'alex', 'tom', 'jerry', 'jack', 'rose'}

```

清除集合所有元素

def clear(self, *args, **kwargs)：

name_set = {'tom','jerry','alex','rose'}

name_set.clear()

print(name_set)

set()

```

浅拷贝

def copy(self, *args, **kwargs):

name_set = {'tom','jerry','alex','rose'}

name_set_copy = name_set.copy()

name_set_copy

{'tom','jerry','alex','rose'}

```

集合A中存在，集合B中不存在的元素

def difference(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose','eric'}

A_set.difference(B_set)

{'tom'}

```

从当前集合中删除和B中相同的元素

def difference_update(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose','eric'}

A_set.difference_update(B_set)

A_set

{'tom'}

```

移除指定元素，不存在不保错

def discard(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

A_set.discard('eric')

A_set

{'tom','jerry','jack','rose'}

```

移除指定元素，不存在报错

def remove(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

A_set.remove('eric')

Traceback (most recent call last):

File "", line 1, in

A_set.remove('eric')

KeyError: 'eric'

```

随机移出元素，当集合为空时报错

def pop(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

A_set.pop()

'jack'

A_set.pop()

'jerry'

A_set.pop()

'tom'

A_set.pop()

'rose'

A_set.pop()

Traceback (most recent call last):

File "", line 1, in

A_set.pop()

KeyError: 'pop from an empty set'

```

两个集合的交集

def intersection(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose','eric'}

A_set.intersection(B_set)

{'jack', 'rose', 'jerry'}

```

取A,B两个集合的交集并将交集更新到A中

def intersection_update(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose','eric'}

A_set.intersection_update(B_set)

A_set

{'jack', 'rose', 'jerry'}

```

A,B两个集合如果没有交集，返回True，否则返回False

def isdisjoint(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose','eric'}

A_set.isdisjoint(B_set)

False

```

集合B是否是集合A的子序列

def issubset(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose'}

B_set.issubset(A_set)

True

```

集合A是否是集合B的父序列

def issuperset(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose'}

A_set.issuperset(B_set)

True

```

对称差集

def symmetric_difference(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose','eric'}

A_set.symmetric_difference(B_set)

{'tom', 'eric'}

```

对称差集,并更新到A中

def symmetric_difference_update(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose','eric'}

A_set.symmetric_difference_update(B_set)

A_set

{'eric', 'tom'}

```

并集

def union(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose','eric'}

A_set.union(B_set)

{'jerry', 'jack', 'eric', 'rose', 'tom'}

```

更新

def update(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose','eric'}

A_set.update(B_set)

A_set

{'jerry', 'jack', 'eric', 'rose', 'tom'}

```

函数

函数定义

def 函数名(参数):
    ...
    函数体
    ...
    返回值

def：表示函数的关键字
函数名：函数的名称，日后根据函数名调用函数
函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
参数：为函数体提供数据
返回值：当函数执行完毕后，可以给调用者返回数据。

函数返回值:

默认情况下如果用户不加函数返回值函数会返回None，关键字是return

例子：

def 发送短信():
    发送短信的代码...
    if 发送成功:
        return True
    else:
        return False
while True:
    # 每次执行发送短信函数，都会将返回值自动赋值给result
    # 之后，可以根据result来写日志，或重发等操作
    result = 发送短信()
    if result == False:
        记录日志，短信发送失败...

函数的参数

普通参数
默认参数
动态参数

例子：

普通参数:

#name,age叫做形参（形式参数）
def func(name,age):
    print name
#'tom',18叫做实参（实际参数）
func('tom',18)

默认参数:

def func(name, age = 18):
    print("%s:%s" %(name,age))
# 普通参数
func('tom', 19)
# 使用默认参数
func('jerry')
程序结果：
tom:19
jerry:18
注：默认参数需要放在参数列表最后

动态参数:

def func(*args):
    print args
# 可将多个参数传至args，args = (11,33,4,4454,5)
func(11,33,4,4454,5)
# 如果传li的话arg = ([11,2,2,3,3,4,54],),*li的话args = (11,2,2,3,3,4,54)
li = [11,2,2,3,3,4,54]
func(*li)

def func(**kwargs):
    print kargs
# kargs = {'name':'tom','age':18}
func(name＝'tom',age=18)
# 传**li   kargs = {'name':'tom', age:18, 'gender':'male'}
li = {'name':'tom', age:18, 'gender':'male'}
func(**li)

def func(*args, **kwargs):
    print args
    print kwargs
注意：这两个形参不能调换顺序，就像默认参数必须放在形参列表最后一样。

内置函数

abs()

取绝对值

abs(-10)

10

abs(10)

10

```

all()

传一个可迭代的参数，如列表，只要列表中所有的值为真返回值才为真，有一个为假返回值就为假

all([0,True,[1,2],{'name':'tom'}])

False

all([1,True,'a',[1]])

True

```

any()

和all()正好相反

any([0,False,[],{},'hello'])

True

any([0,False,[],{},''])

False

```

ascii()

忘了

ascii('张')

"'\u5f20'"

```

bin()

将10进制转换成2进制(数字前面0b代表2进制)

bin(2)

'0b10'

bin(10)

'0b1010'

```

oct()

将10进制转换成8进制(数字前面0o代表8进制)

oct(8)

'0o10'

oct(2)

'0o2'

```

hex()

将10进制转换成16进制(数字前0x代表16进制)

hex(15)

'0xf'

hex(10)

'0xa'

hex(9)

'0x9'

```

bool()

返回True或False

bool(1)

True

bool(0)

False

bool([])

False

bool([1,2])

True

```

bytes()

忘了

bytes('张',encoding='gbk')

b'\xd5\xc5'

bytes('张',encoding='utf-8')

b'\xe5\xbc\xa0'

```

callable()

检查对象object是否可调用,像函数，类也可被调用，实例是不可被调用，除非类中声明了__call__方法

def func():

... pass

...

callable(func) #函数是可被调用的

True

callable(str) #类可被调用

True

s = 'abcd'

callable(s)

False

help

```

chr()

返回整数i所对应的Unicode字符（python2.7是返回整数i所对应的ASCII字符）

chr(65)

'A'

```

ord()

和chr()相反。

ord('A')

65

```

compile()

将source编译为代码或者AST对象。代码对象能够通过exec语句来执行或者eval()进行求值。

s = "print('hello,world!')"

result = compile(s,'','exec')

exec(result)

hello,world!

```

complex()

复数

```

dict()

字典类

dic = dict() #创建一个空字典

dic

{}

```

dir()

不带参数时，返回当前范围内的变量、方法和定义的类型列表；

带参数时，返回参数的属性、方法列表。

如果参数包含方法__dir__()，该方法将被调用。当参数为实例时。

如果参数不包含__dir__()，该方法将最大限度地收集参数信息

dir()

['builtins', 'doc', 'loader', 'name', 'package', 'spec', 'dic']

s = 'hello'

dir(s)

['add', 'class', 'contains', 'delattr', 'dir', 'doc', 'eq', 'format', 'ge', 'getattribute', 'getitem', 'getnewargs', 'gt', 'hash', 'init', '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']

```

divmod()

获取商和余数

divmod(100,2)

(50, 0)

divmod(100,3)

(33, 1)

divmod(120.0,7)

(17.0, 1.0)

divmod(129.5,7)

(18.0, 3.5)

```

enumerate()

返回一个可枚举的对象,该对象的next()方法将返回一个tuple

li =['a','b','c','d','e']

s = enumerate(li)

print(list(s))

[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd'), (4, 'e')]

dic = dict()

for i,v in enumerate(li):

... dic[i] = v

...

dic

{0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e'}

```

eval()

计算表达式的值

s = '8*8'

eval(s)

64

```

exec()

执行python代码

s = "print('hello,world')"

exec(s)

hello,world

```

filter()

过滤，筛选符合条件的值。

li = [10, 20, 30, 40, 50]

result = filter(lambda num: num > 20, li) #简单的函数可用lambda表达式代替

print(list(result))

```

float()

将整数或数字字符串转换成浮点数

float(10)

10.0

num = '100'

float(num)

100.0

```

format()

字符串格式化

s = "I'm {0},{1} years old!"

s.format('tom',18)

"I'm tom,18 years old!"

s = "I'm {name},{age} years old!"

s.format(name='tom',age=18)

"I'm tom,18 years old!"

```

globals()

返回一个字典，字典包含范围内的所有全局变量

print(globals())

{'loader': <class '_frozen_importlib.BuiltinImporter'>, 'v': 'e', 'builtins': <module 'builtins' (built-in)>, 'spec': None, 'package': None, 's': "I'm {name},{age} years old!", 'dic': {0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e'}, 'li': ['a', 'b', 'c', 'd', 'e'], 'i': 4, 'name': 'main', 'doc': None, 'num': '100'}

```

hash()

创建一个hash值

s = 'hello,world'

hash(s)

6931535528834423677

```

help()

查看帮助信息

li = [1,2,4,3]

help(li.sort)

Help on built-in function sort

sort(...) method of builtins.list instance

L.sort(key=None, reverse=False) -> None -- stable sort IN PLACE

```

id()

查看对象的内存地址

s = 'hello,world'

id(s)

139749839772464

```

input()

等待用户输入

s = input('username:')

username:tom

print(s)

tom

```

int()

转换成整型数

s = '10' #将字符串强转成数字

int(s)

10

f = 15.3 #将浮点数转换成整型数，会损失精度

int(f)

15

```

isinstance()

判断对象是否是某个类的实例

s = 'hello,world'

isinstance(s,str) #判断s是否是str类的实例

True

isinstance(s,dict)

False

```

len()

求对象的长度或元素的个数

s = 'hello,world'

len(s)

11

li = [1,2,3,4,5]

len(li)

5

t = (1,2,3,4,5)

len(t)

5

```

list()

创建列表或转换成列表

li = list() #创建一个空列表

li

[]

```

locals()

查看所有局部变量

```

map()

此函数有两个参数，第一个是函数名，第二个是可迭代的对象。遍历每个元素，执行function操作

li = [10,20,30,40,50]

result = map(lambda num:num+100,li)

print(list(result))

[110, 120, 130, 140, 150]

```

max()

求最大值，参数可以传一个可迭代的对象，如列表，返回最大的元素;如果是两个或两个以上的参数，返回最大的那一个

max(10,20,40,60) #传多个参数

60

li = [10,20,40,50] #传一个列表

max(li)

```

min()

求最小值，参数和max()一样，返回最小的那个元素或值

li = [10,20,40,50]

min(li)

10

min(10,20,40,50)

10

```

open()

文件操作，打开文件

f = open('test.txt','r') #以只读的方式打开test.txt文件

```

pow()

求第一个参数的第二个参数次方

pow(2,10)

1024

```

print()

格式化输出函数

print('hello,world')

hello,world

print("I'm %s,%d years old" %('tom',18))

I'm tom,18 years old

```

range()

产生一个序列，默认从0开始

list(range(6))

[0, 1, 2, 3, 4, 5]

list(range(1,6))

[1, 2, 3, 4, 5]

list(range(0,6,2))

[0, 2, 4]

```

repr()

返回一个字符串可打印对象

repr('hello')

"'hello'"

```

reversed()

反转，和列表里的reversed基本一样，他会去调用列表里的resversed方法

li = [1,2,3,4,5]

reversed(li)

<list_reverseiterator object at 0x7f1a0b8988d0>

list(reversed(li))

[5, 4, 3, 2, 1]

```

round()

四舍五入

round(5.6)

6

round(5.4)

5

```

set()

创建一个空集合，或者转换成一个集合

s = set() #创建空集合

s

set()

s = set([1,2,4,4,5]) #传入一个可迭代的对象，将列表转换为集合

s

{1, 2, 4, 5}

```

slice()

切片

```

sorted()

排序,和list类里的sort方法相似

li = [1,5,3,4,2]

sorted(li)

[1, 2, 3, 4, 5]

li

[1, 5, 3, 4, 2]

sorted(li,reverse=True)

[5, 4, 3, 2, 1]

```

str()

字符串类

str(231)

'231'

```

sum()

求和

sum([1,2,3,4,5]) #参数为可迭代的对象

15

```

tuple()

返回一个不可变的元组

t = tuple() #创建一个空元组

t

()

t = tuple([1,2,3,4,5]) #传入一个列表，将列表转换成元组

t

(1, 2, 3, 4, 5)

```

type()

查看对象数据类型

t

(1, 2, 3, 4, 5)

type(t)

<class 'tuple'>

type('hello')

<class 'str'>

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

<class 'list'>

```

vars()

返回对象的属性,当不加参数的时，等同locals(),当有一个参数时，这个参数必须有__dict__属性

vars()

```

zip()

解释起来好复杂，直接看例子吧

li1 = [1,2,3]

li2 = [4,5,6]

zip(li1,li2)

<zip object at 0x7f1a0b889048>

list(zip(li1,li2))

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

```

未完待续。。。

局部变量和全局变量

局部变量

在函数字义内定义的变量为局部变量，只能在函数体内使用。

def func1():
    name = 'tom'
    age = 18
    print('I am %s,%d years old!' % (name,age))
func1()
print('I am %s,%d years old!' % (name,age))  #在函数体外无法找到这两个变量
执行结果：
I am tom,18 years old!
Traceback (most recent call last):
  File "local.py", line 10, in <module>
    print('I am %s,%d years old!' % (name,age))
NameError: name 'name' is not defined

全局变量

在文件头定义，并且在函数体外定义的为变量为全局变量，在python中全局变量虽然没有规定大不写，但是我们约定全局变量都大写。

全局变量在函数内只能读取，不能修改，如果想要在函数内修改得在函数内加global关键字

NAME = 'jerry'
AGE = 20
def func1():
    NAME = 'jack'  #注意，这并不是修改的全局变量，这相当于字义了一个和全局变量名字相同的局部变量
    AGE = 30
    name = 'tom'
    age = 18
    print('I am %s,%d years old!' % (name,age))
    print('I AM %s,%d YEARS OLD!' % (NAME,AGE))
func1()
print('I am %s,%d years old!' % (NAME,AGE))
程序结果：
I am tom,18 years old!
I AM jack,30 YEARS OLD!
I am jerry,20 years old!

如果想在函数里修改全局变量，则需要global关键字

NAME = 'jerry'
AGE = 20
def func1():
    global NAME
    global AGE
    NAME = 'jack'  #注意，这并不是修改的全局变量，这相当于字义了一个和全局变量名字相同的局部变量
    AGE = 30
    name = 'tom'
    age = 18
    print('I am %s,%d years old!' % (name,age))
    print('I AM %s,%d YEARS OLD!' % (NAME,AGE))
func1()
print('I am %s,%d years old!' % (NAME,AGE))
程序结果：
I am tom,18 years old!
I AM jack,30 YEARS OLD!
I am jack,30 years old!

文件操作

文件操作的三个步骤：

打开文件
操作文件
关闭文件

操作文件的函数：

文件句柄 = open('文件路径', '模式')

打开文件

打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。

打开文件的方式有：

r，只读模式,如果open打开文件不指定打开模式，默认为只读模式
w，只写模式，如果文件不存在则创建，存在则清空文件内容
x, 只写模式，不可读；不存在则创建，存在则报错。python3中才有的，python2中没有这个方式。
a, 追加模式可读,不存在则创建；存在则只追加内容；

"+" 表示可以同时读写某个文件

r+，读写,可读，可写(最常用)
w+，写读,可读，可写
x+ ，写读,可读，可写
a+，写读,可读，可写

"b"表示以字节的方式操作

rb 或 r+b
wb 或 w+b
xb 或 w+b
ab 或 a+b

注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型

操作文件

操作文件的方法：

关闭文件

def close(self, *args, **kwargs):

f = open('test.txt','w')

f.close()

```

打开文件描述符

def fileno(self, *args, **kwargs):

f = open('test.txt','r')

f.fileno()

3

```

刷新文件内部缓存区

def flush(self, *args, **kwargs):

f = open('test.txt','w')

f.write('hello,world!') #这时内容还在缓存区里保存着，并没有写到磁盘上

f.flush() #强刷缓存区的内容到磁盘

```

判断文件是否是tty设备(linux系统)

def isatty(self, *args, **kwargs):

f = open('test.txt','w')

f.isatty()

False

```

读取指定字节数据

def read(self, *args, **kwargs):

f = open('test.txt','r')

f.read(10)

'hello,worl'

```

是否可读

def readable(self, *args, **kwargs):

f = open('test.txt','w')

f.readable()

False

```

仅读取一行数据

def readline(self, *args, **kwargs):

f = open('test.txt','r')

f.readline()

'hello,world!\n'

f.readline()

'hello,python!'

```

指定文件中的指针位置

def seek(self, *args, **kwargs):

f = open('test.txt','r')

f.seek(10) #移动到第10个字符

10

f.read(5) #从第10个字符开始读5个字符

'd!\nhe'

```

指针是否可操作

def seekable(self, *args, **kwargs):

f = open('test.txt','a')

f.seekable()

True

```

获取指针位置

def tell(self, *args, **kwargs):

f.close()

f = open('test.txt','r')

f.tell()

0

```

写内容

def write(self, *args, **kwargs):

f = open('test.txt','w')

f.write('hello,word!')

11

f.close()

```

是否可写

def writable(self, *args, **kwargs):

f = open('test.txt','r')

f.writable()

False

f.close()

f = open('test.txt','w')

f.writable()

True

f.close()

```

管理上下文

为了避免打开文件后忘记关闭，可以通过管理上下文，即：

with open('log','r') as f:
    ...

如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。

在Python 2.7 及以后，with又支持同时对多个文件的上下文进行管理，即：

with open('text.txt') as f1, open('text2.txt') as f2:
    pass

三元运算

学习条件运算时，对于简单的 if else 语句，可以使用三元运算来表示，即：

# 普通条件语句
if 1 == 1:
    name = 'tom'
else:
    name = 'jerry'
# 三元运算
name = 'tom' if 1 == 1 else 'jerry'

lambda表达式

对于简单的函数，也存在一种简便的表示方式，即：lambda表达式

# 定义函数（普通方式）
def func(arg):
    return arg + 1
# 执行函数
result = func(123)
# 定义函数（lambda表达式）
my_lambda = lambda arg : arg + 1
# 执行函数
result = my_lambda(123)