Python-03-基础

一、集合

集合(set)是一个无序的、不重复的元素组合，它的主要作用如下：

• 去重：把一个列表变成集合，就会自动去重。
• 关系测试：测试两组数据之前的交集、差集、并集等关系。

常用操作

# 创建数值集合
list_1 = set([1,2,3,4,5])
list_2 = set([5,6,7,8,9])
list_3 = set([1,2,3])

# 常用操作：
# 1.交集(两个集合相同的部分)
list_1.intersection(list_2)             # 方法1
list_1 & list_2                         # 方法2
# 2.并集(合并两个列表，并去重)
list_1.union(list_2)                    # 方法1
list_1 | list_2                         # 方法2
# 3.差集（list1中有list2中没有的部分）
list_1.difference(list_2)               # 方法1
list_1 - list_2                         # 方法2
# 4.对称差集(取出两个列表中互不相同的部分)
list_1.symmetric_difference(list_2)     # 方法1
list_1 ^ list_2                         # 方法2
# 5.子集
list_3.issubset(list_1)                 # 方法1
list_3 <= list_1                        # 方法2
# 6.父集
list_1.issuperset(list_3)               # 方法1
list_1 >= list_3                        # 方法2
# 7.是否有交集
list_3.isdisjoint(list_1)               # True or False

# 增删改查
# 1.添加
list_1.add('999')                # 添加1个元素
list_1.update([888,777,666])     # 添加多个元素
# 2.删除
list_1.remove('3')               # 从集合中移除一个元素，没有此元素时,raise KeyError
list_1.discard('4')              # 移除集合里的一个元素，如果给的参数不是集合里的元素，则什么都不做
list_1.pop()                     # 随机删除并显示已删除的项
list_1.clear()                   # 移除集合内的所有元素
# 3.浅复制
list_1.copy()                    # 返回list_1的一个浅复制
# 4.包含
1 in list_1                      # 测试1是否是list_1的成员
9 not in list_1                  # 测试9是否不是list_1的成员
# 其他
len(list_1)                      # list_1的长度

---

二、编码转换

想了解更详细请点击这里

Python3中的编码转换

Python3中默认是Unicode编码

#!/usr/bin/env python
#-*- coding:utf-8 -*-

name = "周杰伦"
# 转为UTF-8编码
print(name.encode('UTF-8'))
# 转为GBK编码
print(name.encode('GBK'))
# 转为GB2312
print(name.encode('GB2312'))

Python2中的编码转换

因为在python2.X中默认是ASCII编码，你在文件中指定编码为UTF-8，但是UTF-8如果你想转GBK的话是不能直接转的，的需要Unicode做一个转接站点。

#!/usr/bin/env python
#-*- coding:utf-8 -*-

import sys
print(sys.getdefaultencoding())

msg = "周杰伦"
msg_gb2312 = msg.decode("utf-8").encode("gb2312")
gb2312_to_gbk = msg_gb2312.decode("gbk").encode("gbk")

print(msg)
print(msg_gb2312)
print(gb2312_to_gbk)

---

三、文件操作

对文件操作的流程：

1. 打开文件，得到文件句柄并赋值给一个变量
2. 通过句柄对文件进行操作
3. 关闭文件

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

打开文件的模式有：

• r，只读模式（默认）。
• w，只写模式。【不可读；不存在则创建；存在则删除内容；】
• a，追加模式。【可读； 不存在则创建；存在则只追加内容；】

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

• r+，可读写文件。【可读；可写；可追加】
• w+，写读
• a+，同a

"U"表示在读取时，可以将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用）**

• rU
• r+U

"b"表示处理二进制文件(如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注)

• rb
• wb
• ab

open文件操作演示

f = open('data.txt', 'r', encoding='utf-8')
print(f.tell())
# 按照字符读
f.read(2)
# tell()返回的是根据字节得到的位置
print(f.tell())
# seek()指定当前指针位置，seek()用的是字节
# 由于有中文，所以把指针指向1，就会报错，因为一个中文包括三个字节
# f.seek(1)
# print(f.read())

# truncate():把当前指针位置之前的数据保留下来，舍去后面的（需用a+模式）
f.close()

with语句

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

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

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

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

with open('data1') as obj1, open('data2') as obj2:

    pass

---

四、函数

函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可

def 函数名(参数):

    ...
    函数体
    ...

函数的定义主要有如下要点：

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

语法定义

def test1():
    print("Hello test1")

test1()      #调用函数

含有参数的函数

def test2(a,b):
    res = a**b
    return res    #返回函数执行结果

c = test2(5,6)
print(c)

返回值

函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。

注意：

1. 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，return 语句代表着函数的结束
2. 如果未在函数中指定return,那这个函数的返回值为None

函数参数与局部变量

• 形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
• 实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

# 定义函数
def list(name):         # name叫做函数list的形式参数，简称：形参。
    print(name)

# 执行函数
list('zhubajie')        # 'zhubajie'叫做函数list的实际参数，简称：实参。

默认参数

def list(name,age = 18):
    print(%s:%s % (name,age))

# 指定参数执行函数
list('zhubajie',99)
# 使用默认参数执行函数
list('zhubajie')
# 注：默认参数需要放在参数列表最后

动态参数1：

# *args 会把多传入的参数变成一个元组形式

def func(*args):

    print args

# 执行方式一
func(11,33,4,4454,5)

# 执行方式二
li = [11,2,2,3,3,4,54]
func(*li)

动态参数2：

# *kwargs 会把多传入的参数变成一个字典形式

def func(**kwargs):

    print args

# 执行方式一
func(name＝'wupeiqi',age=18)

# 执行方式二
li = {'name':'wupeiqi', age:18, 'gender':'male'}
func(**li)

动态参数3：

# 多种动态参数可共用

def func(name,*args, **kwargs):

    print name
    print args
    print kwargs

局部变量

全局与局部变量:

在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。

全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

name = "外国"

def change_name(name):
    print("before change:",name)
    name = "内地"
    print("after change：", name)

change_name(name)

print("在外面看看name改了么?",name)

输出

before change: 外国
after change：内地
在外面看看name改了么? 外国

递归

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

def calc(n):
    print(n)
    if int(n/2) ==0:
        return n
    return calc(int(n/2))

calc(10)

输出：
10
5
2
1

递归特性:

1. 必须有一个明确的结束条件
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

匿名函数（lambda表达式）

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

# 普通条件语句
if a == 1:
    name = 'zhubajie'
else:
    name = 'sunwukong'

# 三元运算
name = 'zhubajie' if a == 1 else 'sunwukong'

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

# ###################### 普通函数 ######################
# 定义函数（普通方式）
def func(arg):
    return arg + 1

# 执行函数
result = func(123)

# ###################### lambda ######################

# 定义函数（lambda表达式）
my_lambda = lambda arg : arg + 1

# 执行函数
result = my_lambda(123)

lambda存在意义就是对简单函数的简洁表示。

高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

def add(x,y,f):
    return f(x) + f(y)

res = add(3,-6,abs)

print(res)