python基本原理-Python理论基础知识复习

Python简介与基础

Python控制结构

组合数据类型

综述

组合数据类型更能够将多个同类或不同类型组织起来，通过单一的表示使数据更有序、更容易。根据数据之间的关系，组合数据类型可以分为3类：序列类型、集合类型和映射类型。

序列类型是一个元素向量，元素之间的存在先后关系，通过序号访问，元素之间不排他。

集合类型是一个元素类型，元素之间无序，相同元素在集合中唯一存在。

映射类型是键值数据项的组合，每个元素是一个键值对，没有顺序，键唯一存在。

附：序列类型和映射类型是一类数据类型的总称，不是具体类型。

序列类型

序列类型通用函数

序列类型（元组，字符串，列表都可以使用以下操作）

操作符

运算

x (not) in s

是否在内，输出正误

s + t

连接st，不是按索引求和

s * t (t * s)

重复

s[i]

索引

s[i:j:k]

切片

len(s)

求长

min/max(s)

求最值（str比ASCII）

sum(s)

求和

s.index(x)

x第一次出现的索引

s.count(x)

x出现总数

sorted(iter, key, reverse)

返回新的排序后序列类型

reversed()

返回倒序后迭代器，建议再套个list()

enumerate(A[, start=0])

返回迭代器，套list()后形成索引与值的元组列表

a = [1,2,3,4] b=a[::-1]这是切片，切片是得到了一个新的列表，属于浅拷贝，对a修改不影响b，反过来也是。

字符串

字符串是不可变类型，所以字符串方法不改变原字符串，而是生成新副本。

函数和处理方法

描述

str(x)

返回任意类型对应字符串形式

chr(x)

十六进制/十进制Unicode转单字符

ord(x)

单字符转Unicode，得到十进制数

hex(x)

返回整数x对应16进制数小写形式字符串

oct(x)

返回整数x对应8进制数小写形式字符串

bin(x)

返回整数x对应2进制数小写形式字符串

str.lower()

返回副本，全小写

str.upper()

返回副本，全大写

str.split(sep=None)

返回列表，str根据sep分隔，默认空格

str.count(s)

数数

str.replace(old, new)

返回副本，old都被改为new

str.center(width, fillchar)

宽度不够就输出全部，居中，fillchar默认空格（可修改为单字符）

str.strip(chars)

去掉str两侧chars列出的字符

str.join(iter)

将iter（主体，一种组合数据类型）变量的

每一个元素后增加一个str字符串（客体）

a=" ".join(["1","2","3"]) #a = "1 2 3"

a=" ".join([1,2,3]) #出错

数值类型转换

#int(x)

#str类int/int/float => int

int("12") #输出12，支持str类int

int(12.34) #输出12，支持float

int("101",2) #输出5，进制转换必须str类int

int("12.34") #出错

int("12g") #出错

int(12g) #出错

int(101,2) #出错

int("101.5",2)#出错

#float(x)

#int/str类 => float

float(12)

float("12")

float(12.0)

float("12.0") #都输出12.0

#str(x)

#int/float => str类

str(10.01) #输出"10.01"

str(1010+101) #输出"1111"

str("1010"+"101") #输出"1010101"

列表

是有序序列，但内部可以更改，列表无长度限制，元素类型可以不同，不需要预先定义长度。

列表创建方法如下：

a=[1010,"1010",[1010,"1010"]]

a=list("由字符串生成一个字一个元素")

a=list() #空列表

由于类型可变

就有

ls[i]=k 在原列表修改某个元素

ls[i:j:k]=lt 在原列表一部分改为新列表

ls=[i for i in range(6)]

ls[1:5:2]=["a","b"] #如果个数不对会出错

print(ls) #输出[0, "a", 2, "b", 4, 5, 6]

del [i]/[i:j:k] 删除一部分

当然也有len(ls) ls.index(x) ls.count(x) x (not) in ls +/* min/max(x) list(x) 等方法操作

list(x) 将变量x转化为列表类型，可以是字符串、集合也可以是字典（但是形成的是键的列表）

列表的特殊函数与操作

由于列表可变，几乎所有方法不需要ls=ls.fn(x)，因为原列表已经被改变。

如果写成l(或者是另外的a变量)=ls.fn(x)，只会得到None

直接ls.fn(x)才是对的。

函数和处理方法

描述

ls.append(x)

在最后加元素

ls.insert(i, x)

在第i位置加元素x

ls.clear()

清空

ls.pop(i)

取出并返回第i位置元素并删除，默认最后一个元素

ls.remove(x)

删除第一次出现的元素x，不返回

ls.reverse()

元素反转（类比序列方法reversed()）

ls.sort(reverse=False, key=None)

列表排序（类比序列方法sorted()）

str.split(sep=None)

返回列表，str根据sep分隔，默认空格

str.count(s)

数数

ls.copy()

例外，生成新列表，浅拷贝

元组

不可更改的序列类型（但是元组中可变的元素仍然是可以进行修改的，做字典的键的元组不能含可变的列表、字典、集合），元组可以实现的操作都可以由列表完成，如果不需要修改数据可以把列表换成元组类型，python对元组处理效率高。

元组创建方法如下：

a=(1, 2, 3)

a=1, 2, 3

a=(1, )

a=1,

a=tuple()

a=()

#以下错误，括号只能放一个序列类型

a=tuple(1, 2, 3)

#以下正确

a=tuple([1, 2, 3]) #a=[1, 2, 3]

a=tuple({2:3, 4:5}) #a=[2, 4]

当函数返回多个值，多个返回值以元组类型返回，实际上是返回一个数据类型。

def f(x):

return x, x+1, x+2

print(type(f(1))) #输出

集合

集合中的元素不可重复，元素类型只能是不可变数据类型（整数，浮点数，字符串，元组等），不能是列表，字典，集合。

集合可以进行数据去重操作。

集合元素间不能比较和排序。

空集合用set()表示，对比{}表示空字典

操作符

运算

S-T

差集

S&T

交集

S|T

并集

S^T

对称差分

可以使用S-=T进行增强操作，运算的同时更新S集合

集合类型常用的函数或方法

函数或方法

描述

S.add(x)

把x加到S中（类比列表L.append(x)）

S.remove(x)

移除x，不存在会产生KeyError异常

S.discard(x)

移除x，不存在也不报错（与上对比）

S.clear()

移除所有数据但不去除集合本身

S.pop()

随即返回并删除这个元素来更新S，如果s为set()会产生异常

其他也有len(S) x (not) in S S.copy()（浅拷贝）等

字典

不可变组合类型、基本数据类型可以作为键，元组在各个元素不可变时可做键，列表、集合和其他字典不可做键。

对字典for i in d遍历时，i是字典的每一个键

字典函数和方法

操作符

运算

d.keys()

返回所有键

d.values()

返回所有值

d.items()

返回所有键值对

d.get(a key, default=)

键存在返回相应值，

否则返回默认

增加新键值对

d.pop(a key, default=)

键存在返回相应值

并删除键值对

否则返回默认

d.popitem()

随机取出键值对，以元组返回并删除键值对

d.clear()

成为空字典

del d[x]

删除以x为键的键值对

注意：keys，values，items方法返回的是特殊的内部数据类型，想更好的使用返回数据最好利用list()转化成列表，键值对以元组类型储存在列表里。

字典与序列类型类似的通用操作

in 判断一个键是否在字典中

len(d)字典键值对数量

min/max(b) 返回最小最大的索引值（前提是字典中各个索引元素可以比较）

字典的索引

print(d[x]) #输出x对应的键

d[x] = 1 #修改字典键值对，也可以增加新键值对

字典创建方法如下：

a={"1":2, "3":4}

a=dict()

a={}

#错误方法

a={(1,2), (3,4)} #创建的是含两个元组的集合

#正确方法可使用dict()，这个括号里只能有一个大类，大类里有小类，每个小类两个元素（长为2）

a=dict(([1,2], [3,4]))

a=dict([((1,2),2), ((3,),4)])

深拷贝与浅拷贝

python中，变量与变量的值占用不同的内存。变量占用的内存，并非直接存储数值，而存储的是值在内存中的地址。

ls = ["中国","矿业","大学"]

ls1 = ls #ls1 = ls 实际上是ls1指向了ls指向的地址块，两者指向的是同一块地址区域，不是拷贝

print(ls1) #输出ls = ["中国","矿业","大学"]

ls.append("憨憨") #对ls进行元素操作时，也是对ls1造成影响

print(ls1) #输出["中国", "矿业", "大学", "憨憨"]

ls2 = ls[:] #利用切片，在内存中新建了一个列表，ls2指向这个新的列表，浅拷贝

print(ls2) #输出ls = ["中国","矿业","大学", "憨憨"]

ls.append("憨包") #对ls的元素进行任何操作，都不会影响ls2的内容

print(ls2) #输出ls = ["中国","矿业","大学", "憨憨"]

a = 1 b= a这不是拷贝，赋值是多个变量指向同一个内存地址，内存的任一元素改变，所有变量都受影响

a = [1,2,3,4] b=a[:]这是切片，切片是得到了一个新的列表，属于浅拷贝

浅拷贝x.copy()

对只有一层元素关系的列表进行测试：

ls = ["python","c","cpp"]

ls1 = ls.copy()

print(id(ls),id(ls1)) #输出 2551633171528 2551633985416，可见二者指向的内存地址不同

ls.append("php")

ls1.append("java")

print(ls) #输出 ["python", "c", "cpp", "php"]，对ls的append操作没有影响ls1

print(ls1)#输出 ["python", "c", "cpp", "java"]，对ls1的append操作没有影响ls

从以上结果可得：在copy完之后，新的列表指向新的内存地址，分别对列表的最后一位进行appen操作，结果互不影响。

对具有二层的元素的列表进行测试：

##对ls的第二个元素进行append操作

ls = ["德玛",["费欧娜","戴安娜"],"赵信"]

ls1 = ls.copy()

print(ls1) #输出["德玛", ["费欧娜", "戴安娜"], "赵信"]

ls[1].append("莫甘娜") #copy完成后对ls的第二个元素进行append操作

print(ls1) #输出"德玛", ["费欧娜", "戴安娜", "莫甘娜"], "赵信"]，ls1发生了改变

print(id(ls[1]),id(ls1[1])) #查看两者的ID，2202073060424 2202073060424

##对ls1的第二个元素进行操作

ls = ["德玛",["费欧娜","戴安娜"],"赵信"]

ls1 = ls.copy()

print(ls) #输出["德玛", ["费欧娜", "戴安娜"], "赵信"]

ls1[1].append("莫甘娜")#copy完成后对ls1的第二个元素进行append操作

print(ls)#输出"德玛", ["费欧娜", "戴安娜", "莫甘娜"], "赵信"]，ls发生了改变

print(id(ls[1]),id(ls1[1])) #输出 2303581443144 2303581443144

从上边输出的结果来看，copy完成之后，分别对ls和ls1的中间元素进行append操作，对方的元素也会发生相应的改变。

结论：浅拷⻉，只会拷⻉第⼀层内容，只拷贝第二层关系的内存地址，而第⼆层的内容不会拷贝，所以被称为浅拷贝。

深拷贝x.deepcopy()

深拷贝使用之前一定要先加载copy模块

import copy

new_ls = copy.deepcopy(ls)

实例：

#对ls进行二层操作

import copy

ls = ["德玛",["费欧娜","戴安娜"],"赵信"]

ls1 = copy.deepcopy(ls)

ls[1].append("莫甘娜")

print(ls) #输出["德玛", ["费欧娜", "戴安娜", "莫甘娜"], "赵信"]

print(ls1) #输出["德玛", ["费欧娜", "戴安娜"], "赵信"]

#对ls1进行二层操作

import copy

ls = ["德玛",["费欧娜","戴安娜"],"赵信"]

ls1 = copy.deepcopy(ls)

ls1[1].append("莫甘娜")

print(ls) #输出["德玛", ["费欧娜", "戴安娜"], "赵信"]

print(ls1) #输出["德玛", ["费欧娜", "戴安娜", "莫甘娜"], "赵信"]

由以上结果可得：深拷贝是完完全全的复制，是创建一个完完全全的新的对象，新旧对象之间不会相互影响。不可变数据类型新旧列表指向同一个空间，可变类型新列表创建了新的空间。

另附：

a = [1, 2]

a[1] = a #对a列表的第二个元素进行修改成自己

print(a[1]) #输出为[1, [...]]

print(a) #输出为[1, [...]]

print(id(a),id(a[1])) #输出内存地址1191853053000 1191853053000 a与a[1]的内存地址一样

print(type(a[1])) ##输出

分析: a[1] 原来是int类型，在对a[1]进行修改操作时，会先把原来的指向剪断，因为赋值a，指向了自己，此时出现了数据上的死循环。

函数

参数

参数及其传递

#向函数传递信息

def greet_user(username): #username是形参

print("hello," + username + "!" )

greet_user("python") #"python"是实参

在函数名中定义一个形参，函数调用时，给函数名中的形参传递实参。

传递实参的方法有：

位置实参（按照基于实参的顺序关联到形参，有顺序）

关键字参数（类似按照键值对，按照名字进行关联，无顺序问题）

默认值参数（给形参进行固定值作为默认值，如果没有提供实参对默认值进行覆盖处理，则代入默认数值后运行函数）

注意：

两种传参方式可以混合使用，但使用时关键字参数必须位于位置参数之后

可变参数*args与**kwargs

def f(*args, **kwargs):

print("args = ", args)

print("kwargs = ", kwargs)

print()

if __name__ == "__main__":

f(1,2,3,4)

f(a=1,b=2,c=3)

f(1,2,3,4, a=1,b=2,c=3)

f("a", 1, None, a=1, b="2", c=3)

输出结果是

args = (1, 2, 3, 4)

kwargs = {}

args = ()

kwargs = {"a": 1, "c": 3, "b": 2}

args = (1, 2, 3, 4)

kwargs = {"a": 1, "c": 3, "b": 2}

args = ("a", 1, None)

kwargs = {"a": 1, "c": 3, "b": "2"}

这是python中的两种可变参数。

*args表示任何多个无名参数，它是一个tuple

**kwargs表示关键字参数，它是一个dict

同时使用*args和**kwargs时，*args参数必须在**kwargs前，像f(a=1, b="2", c=3, a", 1, None)这样调用的话，会提示语法错误SyntaxError: non-keyword arg after keyword arg

等效的函数调用

函数调用时，无论是使用位置参数还是关键字参数、默认值参数，得到的结果都是一样的。

#一个名为harry的小狗

def describe_pet(pet_name,animal_type = "dog"):

函数省略

describe_pet(pet_name="harry")

describe_pet("harry")

两次使用describe_pet()函数的结果一致

全局变量和局部变量

这是两种不同的变量

局部变量是函数内部的占位符，与全局变量可能重名但是不同

函数运算结束后，局部变量被释放，不再进行储存

可以使用global保留字，从而在函数内部使用全局变量

局部变量为组合数据类型且未创建，等同于全局变量

ls=["x", "y"] #真实创建了一个ls全局变量列表

def f(n):

ls.append(n) #ls是列表类型，没有真实创建，等同于全局变量

return #加不加return都是一样的

f("z") #全局变量被修改

print(ls)

以上输出为["x", "y", "z"]

ls=["x", "y"] #真实创建了一个ls全局变量列表

def f(n):

ls = [] #ls是列表类型，真实创建，在这里ls是局部变量

ls.append(n)

return #加不加return都是一样的

f("z")

print(ls)

以上输出为["x", "y"]

规则总结

基本数据类型，无论是否重名，局部变量与全局变量不同

可以通过global保留字在函数内部声明全局变量

组合数据类型，如果局部变量未真实创建，则是全局变量

另附：

return在不带参数的情况下（或者没有写），默认返回None

文件

数据分析与爬虫

内库与三方库

python基本原理-Python理论基础知识复习相关推荐

python 理论基础知识试题_Python理论基础知识复习
1.Python语言简介与基础 2.Python控制结构 3.字符串与组合数据类型 4.函数 4.1参数 4.1.1参数及其传递 #向函数传递信息 def greet_user(username): ...
汇率兑换程序python按温度转换_python复习+实例编写（1）——温度转换、汇率转换...
(python基础知识复习.温度转换.人民币汇率转换实例) Python语言设计主要分为三步:IPO,即输入.算法.输出. 下面通过一个简单的实例,复习之前学习过的python的部分基础知识. 温度转 ...
Python培训入门基础知识学什么?
Python培训基础知识主要是针对一些零基础的同学安排的,虽说Python是相对比较简单的一门编程语言,但是没有基础的同学还是要进行系统的学习,那么Python培训入门基础知识学什么呢?来看看下面小编 ...
谈谈Python那些不为人知的冷知识（二）
本文转载自Python的编程时光(ID:Python-Time) 小明在日常Code中遇到一些好玩,冷门的事情,通常都会记录下来. 从上一篇的分享来看,仍然有不少 Pythoner 对这些冷知识存在盲 ...
python编程基础知识体系_最新版 17 幅思维导图：Python 编程之核心知识体系
原标题:最新版 17 幅思维导图:Python 编程之核心知识体系导读:本文主要涵盖了 Python 编程的核心知识,展示了一系列思维导图,主要就 Python 核心基础知识进行了细致梳理.无论你是 ...
零基础可以学python吗-学Python需要什么基础知识?零基础可以学Python吗？
学Python需要什么基础知识?一般来说,想要学Python最好具备一定的计算机专业知识,尤其是数学和英语不错的话,对学Python也有一定的帮助.但是零基础的学习者就不能学Python了吗?当然不是 ...
学python需要什么基础知识-学Python需要什么基础知识?零基础可以学Python吗？
学Python需要什么基础知识?一般来说,想要学Python最好具备一定的计算机专业知识,尤其是数学和英语不错的话,对学Python也有一定的帮助.但是零基础的学习者就不能学Python了吗?当然不是 ...
学python需要什么基础知识-学习Python需要知道哪些基础入门知识？
众所周知,Python以优雅.简洁著称,入行门槛低,可以从事Linux运维.Python Web网站工程师.Python自动化测试.数据分析.人工智能等职位!就目前来看,Python就业前景广阔.很多 ...
学python需要什么基础知识-没学过Python先要学习哪些基础知识？
零基础学Python应该学习哪些入门知识关于零基础怎么样能快速学好Python的问题,百度提问和解答的都很多,你可以百度下看看.我觉得从个人自学的角度出发,应从以下几个方面来理解: 1 为什么选择学 ...

python基本原理-Python理论基础知识复习

python基本原理-Python理论基础知识复习相关推荐

最新文章

热门文章