Python 基础

Python中的数据结构

常见的数据结构有六种

• Number：数值
• String：字符串
• List：列表
• Tuple：元祖
• Dictionary：字典
• Set：集合

六种数据结构可以根据特征进行划分

划分	有序	无序
可变	列表	字典，集合
不可变	字符串，元祖	数值

Number 数值

• Python3支持：int flot，bool，complex（复数）几种类型的数值

数值类型的基本操作

• 加 +
• 减 -
• 乘 *
• 除 /
• 取余 %
• 取整 //

String 字符串

• 字符的有序序列，他可以进行 + * 运算， 他是不可变数据类型
• 使用单引号，双引号，三引号又可以声明
• “r”; 字符转变为原始字符串
• ‘’: 字符转义

字符串的常用操作

操作	解释	示例
分隔	str.split(str1):以str1为分隔符对字符串切割	‘python’.split(‘h’) 输出：[‘pyt’,‘on’]
替换	str.replace(str1,str2):将字符串的str1替换为str2生成新的字符串	‘python’.replace(‘py’,‘PY’) 输出：‘PYthon’
小写	str.lower():将字符串中大写字符转换为小写	‘PYTHON’.upper() 输出：‘PYTHON’
大写	str.upper():将字符串中小写字符转换为大写	‘python’.lower() 输出：‘python’
拼接	str.join(iter):将所给参数中的每个元素以指定的字符连接生成一个新的字符串	“-”.join(“huawei”) 输出：‘h-u-a-w-e-i’
格式化输出	格式化操作符(百分号%)，字符串转换类型和格式化操作符辅助指令实现格式化输出	‘My name is %s , age is %d’ %(‘AI’,63) 输出：My name is AI, age is 63

print('python'.split('h'))
print('python'.replace('py','PY'))
print('PYTHON'.lower())
print('python'.upper())
print( "-".join("huawei"))
print('My name is %s , age is %d' %('AI',63))

['pyt', 'on']
PYthon
python
PYTHON
h-u-a-w-e-i
My name is AI , age is 63

List 列表

• 有序序列，其中的元素可以是任意类型，可以随时修改数据
• 由一个有括号包裹住元素，元素用英文逗号分隔，可以直接创建或者使用列表推导式
• “+” “*” 运算（类似于字符串）

列表常用操作

操作	解释	示例
增加	list.append(obj):将参数内的对象添加至列表的尾部 list.insert(index,obj):将对象插入到列表的index位置 list.extend(iter):将可迭代对象的每个元素逐个插入列表的尾部	a = [1,2];a.append(3);a 输出：[1,2,3] a = [1,2];a.insert(0,3);a 输出：[3,1,2] a = [1,2];a.extend([3,4]);a 输出：[1,2,3,4]
删除	list.pop([index]): 删除小别为index的元素，并将其返回（不传参数，默认删除最后一个元素） list.remove(obj): 删除列表中第一个出现的给定元素	a = [1,2];b = a.pop(1);a,b 输出：[1],2 a = [1,2];a.remove(2);a 输出：[1]
查找	list.index(obj): 返回给定元素第一次出现位置的下标	a = [1,2];a.index[2];a 输出: 1
排序	list.sort(): 对列表进行排序，默认升序	a= [3,1,2];a.sort();a 输出：[1,2,3]
逆序	list.reverse(): 将列表中的元素进行逆置（直接修改列表本身）	a = [3,1,2];a.reverse();a 输出：[2,1,3]
数量统计	list.count(obj): 返回给定元素出现的次数	a = [3,1,2,3,1];a.count(1) 输出： 2

a = [1,2]
a.append(3)
print(a)

a = [1,2]
a.insert(0,3)
print(a)

a = [1,2]
a.extend([3,4])
print(a)

[1, 2, 3]
[3, 1, 2]
[1, 2, 3, 4]

Tuple 元组

• 有序序列：和列表相同
• 不可变：数据一旦创建，不可被修改，和字符串类似
• 创建元祖：小括号包裹，元素用逗号隔开
• 长度为1的元祖：元祖只有一个匀速，需要在元素后面加上逗号

为什么需要元祖呢，比如记录身份证号，这个是追随一生的，所以必须是不可变的

Dictionary 字典

• 键值对：元素由两部分组成-键和值，所以以字典的元素也被称为键值对
• 高效率：字典数据的访问速度比列表快
• 创建字典：字典由一对花括号包裹，元素由逗
• 可变且无序：字典的值可以是任意类型，但键是不可变且唯一的。字典是无序的

字典常用操作

操作	解释	示例
获取	dict.get(key,default=None)：根据键获取值，键不存在时返回默认值 dict.items()：返回一个包含所有(键，值)元祖的列表 dict.keys()：返回一个所有键组成的列表 dict.values()：返回一个所有值组成的列表	Dict={‘a’:1,‘b’:2}; Dict.get(‘a’) Dict={‘a’:1,‘b’:2};Dict.items() Dict={‘a’:1,‘b’:2};Dict.keys(); Dict={‘a’:1,‘b’:2};Dict.values()
添加	dict[key] = value; 增加键值对{key:value}，若key已存在，则修改现有的key值	Dict={‘a’:1,‘b’:2}；Dict[‘a’]=3;print(Dict)
更新	dict.update(dict1)：使用dict1对字典进行更新	Dict={‘a’:1,‘b’:2};Dict2={‘a’:3,‘c’:3};Dict.update(Dict2);print(Dict)
删除	dict.pop(key): 删除并返回key对应的值 dict.popitem()：随机删除并返回一个键值对 dict.clear(): 清空字典，但留下一个空的字典，与delete删除的区别；	Dict={‘a’:1,‘b’:2};a=Dict.pop(‘a’);print(Dict) Dict={‘a’:1,‘b’:2}；a = Dict.popitem();print(Dict) Dict={‘a’:1,‘b’:2};Dict.clear();print(Dict)

字典操作的建议

建议不要直接利用键去获取值，当key不存在的时候，直接使用键获取值会报错，当字典很大的时候，可能不存在这个键，就会导致程序直接停止，所以建议使用dict.get()

Set 集合

• 集合中的元素是唯一的，重复的元素会被删除（在需要删除重复数据的list中，可以使用集合）
• 集合是由一个花括号包裹，内部元素以逗号隔开
• 无序且可变的

Set运算

1. 交集：set1 & set2。两个集合中相同的元素
2. 对称差集：set1 ^ set2：两个集合中不同的元素
3. 并集：set1 | set2：两个集合内总共的元素（重复的删除）
4. 差集 set1 - set2：集合1中包含而集合2中不包含的元素

Set常用操作

• 添加
  • set.add(obj)：添加元素，如果元素已经存在，则不会进行任何操作；Set={1,2,3},Set.add(4);print(Set)
  • set.update(obj)：添加对象可以是列表，字典等，且可以是多个，用逗号隔开；Set{1,2};Set.update({2,3});print(Set)
• 删除
  • set.remove(obj)：移除元素（移除不存在的元素时，会抛出异常）；Set={1,2};Set.remove(1);print(Set)
  • set.discard(obj)：删除元素（元素不存在时不会抛出异常）；Set={1,2};Set.discard(1);print(Set)
  • set.clear()：清空集合；Set={1,2};Set.clear();print(Set)
  • set.pop()：随机删除一个元素；Set={1,2}；a=Set.pop();print(Set,a)

数据操作

• 赋值操作：两个变量同时指向了列表的内存地址;不管修改A还是修改B，A和B的值都会进行变化
• 浅拷贝：赋值A中列表数据的表面数据，里面嵌套结构的数据依然只是地址引用；修改嵌套结构中的数据，AB的值都会进行变化
• 深拷贝：完全的数据拷贝；修改A，B不会变化，修改B，A不会变化

import copy
# 赋值操作
A = ["A","b",["c","d"]]
B = A
B[0] = "123"
print("A:{}\nB:{}".format(A,B))

# 浅拷贝
A = ["A","b",["c","d"]]
B = A.copy()
B[2][0] = "123"
print("A:{}\nB:{}".format(A,B))

# 深拷贝
A = ["A","b",["c","d"]]
B = copy.deepcopy(A)
A[0] = "123"
print("A:{}\nB:{}".format(A,B))

A:['123', 'b', ['c', 'd']]
B:['123', 'b', ['c', 'd']]
A:['A', 'b', ['123', 'd']]
B:['A', 'b', ['123', 'd']]
A:['123', 'b', ['c', 'd']]
B:['A', 'b', ['c', 'd']]

运算符

• Python运算符大致有7种，即算术运算符，比较运算符，赋值运算符，逻辑运算符，位运算符，成员运算符以及身份运算符
• 算术运算符，身份运算符，成员运算符比较重要
• 身份运算符就是看内存地址是不是一样
• 成员运算符就是看元素是不是在这个数据结构中

总结

• Python数据结构的比较
  效率方面：dict最快

控制流程语句

控制流语句就是所说的

• 判断语句
• 循环语句

判断语句 - if

• 根据执行条件，自上而下选择执行语句

if 判断条件1:
    执行语句1
elif 判断条件2:
    执行语句2
else:
    执行语句3

在python中：

• True: 1
• False: 0
  在实际运行中，如果是0或者空字符串就是False，其他的1.-1，字符串都是True

循环语句

for循环

for iter in iters:
    循环语句块
else:
    语句块

while循环

while 条件语句:
    循环语句块
else:
    语句块

循环终止

• break: 跳出所有循环
• continue：跳过本次循环

函数

函数：封装了特定功能的代码段

函数的优点

• 重复使用
• 易于维护
• 特定功能
• 模块化
• 可读性

函数的定义

• 关键字def声明函数
• 函数说明
• 语句块缩进
• return
• 匿名函数lambda：轻量型，不常用
• 函数调用

# 定义函数和所需参数
def function(param):
    # 函数说明
    '''说明文档'''
    函数体
    return

# 调用函数
function(param)

# 匿名函数
lamdba x:x+1

参数

python中有下列几种类型的参数

• 必备参数：必备参数须以正确的顺序传入函数，调用时的数量必须和声明时的一样
• 关键字参数：函数调用时使用等号(=)赋值的形式传入参数
• 默认参数：调用函数时，缺省参数的值如果没有传入，则被认为是默认值
• 不定长参数：可能需要一个函数能处理比当初声明时更多的参数，这些参数叫做不定长参数，声明时不会命令。
  • *args：加了星号(*)的变量args会存放所有未命令的变量参数，args为元祖
  • **kwargs：加了双星号(**)的变量会存放命令参数，即形如key=value的参数，kwargs为字典

参数的位置：def func(必备参数，关键字参数，默认参数，必定长参数)

返回值

• 无返回值：函数体中没有return，函数返回None值
• 有返回值：函数体中有return语句，并且返回了相应的表达式或者数值
• 多返回值：多个返回值（不是return多次，是一个return后跟多个值），默认以元祖的形式返回

面向对象

面向对象和面向过程

面向对象中的术语

• 类：类是作为设计蓝图来创建对象的，描述了对象的特征，对象具有的属性，怎样使用对象完成一些任务，它对事件进行相应等
• 对象：对象是类的一个示例，通常通过调用类的一个构造函数来创建它
• 方法：是类中定义的函数，一般而言，一个方法描述了对象可以执行的一个操作
• 属性：属性是类中定义的变量，类的属性突出刻画对象的执行和状态

面向对象三大特性

面向对象的三大特性：封装，继承，多态

• 封装：封装是一个概念，是把方法，属性，事件几种到一个统一的类中，并对使用者屏蔽其中的细节；
• 继承：继承是一种创建类的方法，在现有类(被继承的类)基础上，进行扩展生成新的类，被称为自子类，被继承的类被称为父类，基类，超类
• 多态：一个同样的函数对于不同的对象可以具有不同的实现

面向对象的优势

• 提高代码扩展性
• 提高代码复用性
• 提高代码可维护性

Python中的面向对象

• Python中支持多继承
• Python中创建类的方法

class 类名(父类):
    '''类说明文档'''
    ...类体...

- class：关键字声明类
- 父类可以是多个
- 默认继承object

Python中类的私有化

• 公共属性：正常定义的属性，默认的
• 模块化私有属性：定义类中属性或者方法时，在属性名前加一个"_"
• 完全私有属性：基本上都是使用此私有化，定义类中属性或者方法时，在属性名前加两个"__"

常用标准库和第三方库

标准库：安装完python可以直接使用的库就是标准库
第三方库：没有继承到python解释器里面，需要安装的库

标准库

• 时间处理的库
  • time：time模块是python中处理时间的一个重要模块，包括许多有关时间操作的方法：sleep,localtime,time等
• 系统交互
  • sys：sys模块负责程序与python解释器的交互，用户操作Python运行时的环境，如获取当前的环境变量
• 操作系统
  • os：os模块负责程序与操作系统的交互，提供访问操作系统底层接口；如查看当前的路径，查看对象是文件还是目录，查看当前路径下有哪些文件

第三方库

• 数据分析
  • pandas：分析结构化数据的工具集，用于数据挖掘和数据分析，也提供数据清洗功能
• 数据计算
  • numpy：支持大量的维度数组与矩阵运算，针对数组运算提供大量的数学函数库
• 图形绘制
  • matplotlib：用于绘制2D图形的工具包

IO操作

• 打开操作： f=open(filename,mode,encoding)
• 文件操作：
  • 读：f.read(),f.readline()
    • f.readline:按行读
  • 写：f.write()
• 清空缓存：f.flush()
• 关闭：f.close()