学习笔记：python入门知识点总结（包含List，String等五种数据容器，类与函数的定义）

Python解释器 + pycharm 编译器

解释python语言+编写代码的工具

常见6种值（数据）：数字number(整数int,浮点数float,复数complex,布尔bool),字符串String,列表List(有序记录一堆数据，有序的可变序列)，元组Tuple(有序的不可变序列)，

集合Set(无序不重复集合)，字典Dictionary(无序key-Value集合)

数据类型转换：int(x)x会丢失精度;float(x);str(x)

变量可以存储变量的值，每一个变量都有一个名称，记为变量名称

类名

方法名

标识符命名不可以数字开头，且大小写敏感

Print输出多份数据时，用逗号隔开即可,特殊输出格式见下方

print(f"字符i的值为{i}")

字符串切片：name=”apple”           name[0:3] = “app”       切片取左不取右

                                   name[-1:-3] = “”

循环中断：continue(中断本次循环，进入下一个循环)    break(中止本轮循环)

range(3)=[0,1,2]=range(0,3)    range(1,4)=[1,2,3]    range(1,6,2)=[1,3,5]=range(1,6,7)

序列(包括List,Tuple,String)：内容连续、有序，可使用下标索引的一类数据容器

序列的切片：str[起始下标：结束下标：步长]  # 步长为负数则表示反向取，下标值也要反向标记，步长默认值为1，此时起始下标与结束下标默认为0与n

            Tuple[start:end:step]

List:

列表List的首位索引为0，末位索引为-1，分别对应正向与反向寻址

List.index(元素)  # 查找元素的下标索引值

List[n] = “Davis”  # 修改特定下标的内容

List.insert(n,”Davis”)  # 在下标为n处插入元素”Davis”,原本下标为n的元素向后移位

List.append(“Davis”)  # 在列表最后追加元素

List.extend([“Davis”,”Tony”])  # 在列表最后追加多个元素(一个列表)

del List[n]  # 删除列表下标为n的值（第n+1个值）

NewList = List.pop(n)  # 功能基本同上，取出列表下标为n的值存入NewList

                   # List = [1,2,3]  NewList = List.pop(2)  结果为NewList = [3],List = [1,2]

List.remove(n)  # 删除列表List中下标最小且值为n的元素（n可以为字符串）

List.clear()  # 清空列表，但形式依旧为列表

List.count(“Davis”)  # 计算列表List中内容为”Davis”的元素数量

Count = len(List)  # 列表List的数量有len个

列表推导式：[表达式 for item in 可迭代对象]

[表达式 for item in 可迭代对象 if 条件判断]

[x^2 for x in range(1,5) if x%2==0]

Tuple:

元组=只读的List列表,也可读取到内部的元素

元组的定义：t1 = ()或t1 = tuple()或t1 = (1,”Davis”,True)或t1 = (“Davis”,)或t1 = ( (1,2) , (3,4) )

Tuple.index(“Davis”)  # 寻找Davis所在的下标索引值

Tuple.count(“Davis”)  # 统计tuple中”Davis”的数量

len(Tuple)  # 统计元组元素数量

元组内的元素不能修改，但元素内部List的内部元素是可以修改的

Str:

字符串无法修改

Str.index(“Davis”)  # 查找Davis在字符串中的位置

Str.replace(字符串1，字符串2)  # 将字符串1用字符串2进行替换

Str.split(分隔字符串)  # 字符串本身不变，得到一个列表对象

Str.strip(字符串)  # 字符串的规整操作，包括去前后字符以及指定的字符串

Str.count(“Davis”)  # 统计字符串中Davis出现的次数

len(Str)  # 统计字符串的长度

Set(集合):自带去重功能且内容无序，不支持下标索引，允许修改，可容纳不同类型的数据

用{大括号}定义集合，存放值

set()  # 定义一个空集合

Set.add(“Davis”)  # 添加元素Davis

Set.remove(“Davis”)  # 移除元素Davis

Element = Set.pop()  # 随机取出一个元素，存入element，并在set中移除

Set.clear()  # 清空集合

Set3 = set1.difference(set2)  # 对集合set1与set2取差集(set1 - set2)，set1与set2不改变

#  ( set1.difference(set2) != set2.difference(set1) )

Set1.difference_update(set2)  # set1改变，等价于set1 = set1.difference(set2)

Set3 = Set1.union(Set2)  # set1∪set2

len(Set1)  # 集合内的数量

集合不能用while循环，但可以用for循环

字典(dict)：

用{}定义字典，存放键值对

无重复的key，可有重复的value，类似于x->y的映射，不可使用下标索引，但可使用字典索引

{key1 : value1, key2 : value2, key3 : value3, ... ...}

Dict = {}  # 定义一个空字典

Dict = dict()  # 定义一个空字典

Set = set()  # 定义一个空集合

Dict[“Davis”][“math”]  # 从嵌套字典中提取信息

Dict[key]=value  # 更新(key∈Set)或新增(key不属于Set)字典

Value = Set.pop(“Davis”)  # 字典Set中移除key=Davis的元素并将移除的元素存入Value

Dict.clear()  # 清空字典

Keys = Dict.keys()  # 获取全部的key值存入Keys，用于字典的遍历，也可直接对字典进行for循环

For key in Dict:  # 直接得到key值，用于遍历

len(Dict)  # 得到字典的元素数量

数据容器的通用操作

都支持for循环遍历，列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）

Len，max，min三种通用函数

List，tuple，str，set四种类型转换函数

函数定义为class(类)的成员，那么称这个函数为方法（类内函数）

class Student:之后，方法使用如下

student = Student()

number = student.方法名()

位置参数（根据参数传入位置进行传参）

Def info(name,age,gender):

命名参数/关键字参数（“键=值”的形式进行传参，此时顺序可以打乱）

Def info(name,age,gender):

不定长参数/可变参数（位置传递&关键字传递）：

位置传递：

Def info(*args):

Print(args)  # 其中args为元组格式

关键字传递：

Def info(**kwargs):

Print(kwargs)  # 其中kwargs为字典对象

函数传入多个参数时，可变参数尽量定义在末尾，前面的则为普通参数

若可变参数定义在首位，则后续参数一定为强制命名参数（“形参=实参”的形式）

def function1(*args):
    print(args)


def function2(**kwargs):
    print(kwargs)


function1(1, 2, 3, 4)
function2(name="Davis", age=23)

缺省参数/默认值参数（定义时设置默认值，默认值位置需设置在所有形参的最后）

Def info(name,age=20,gender=’boy’):

传递参数时分为传递可变对象（字典，列表，集合，自定义的对象等）

不可变对象（数字，字符串，元组，function等）

函数作为参数传递(计算逻辑的传递)：

Def func(compute)  # 在参数处调用函数

Result = compute(1,2)

Return result

Def add(x,y):

Return x+y

Print(Func(add))

Lambda表达式和匿名函数

相当于是定义一个只有一行的函数

Eval()函数

Eval函数的输入为一个字符串式的命令，如eval(”print(‘Davis’)”)即可打印Davis

该函数可用来导入txt文件内以字符串为格式的代码

Eval函数还可以以eval(source[,globals[,locals]])的格式进行运行

如eval(“print(a+b)”,dict(a=100,b=200))

深拷贝与浅拷贝

Copy.deepcopy()©.copy()

深拷贝deepcopy会将原变量内的数据全部拷贝至另一地址中，两者在后续不会有任何联系

浅拷贝会将原变量的数据及不定长参数的地址及长度拷贝，两者后续会在拷贝时已有的不定长参数上产生联系。

函数中传递不可变对象时，如果对输入变量进行重新赋值，则是浅拷贝

不可变对象里面包含的子对象是可变的，在方法内秀发i了这个可变对象，源对象也发生了变化

全局变量global与调用外层变量方法nonlocal

Global定义在任何位置都可声明一个全局变量

Nonlocal定义在函数体内部，声明后可用于修改函数体外部的值

面向对象

面向对象与面向过程的区别：

面向过程（Procedure Oriented）思维

该思维更关注“程序的逻辑流程”，是以一种执行者的思维编写小规模程序

该思维适合简单、无需协作的事物

面向对象（Object Oriented）思维

该思维更关注“软件中对象之间的关系”，是以一种设计者的思维编写大规模程序

宏观上解决复杂问题用面向对象把握，微观上处理问题仍是面向过程

对象的进化

从简单数据进化到”数组”

从最初的少量数据类型进化到”结构体”struct

从简单的数据处理方式及逻辑进化到”对象”

类

类的定义

把饼干当作对象，那么模具就是这个类

在程序中定义时，一般首字母大写,多个单词采用驼峰原则

属性需要定义到特殊的方法内

class SeniorHighSchoolStudent:

类的结构

方法（函数）+属性（变量）

行为+状态

对象是类的具体实体，或成为类的实例

从一个类创建对象时，每个对象会共享这个类的行为，即类中定义的方法，但会有不同的属性值（不共享状态），也即不同类的方法是一样的，但数据不一定一样

对象的结构：

方法（由同一个类创建的所有对象共享）+属性（每个对象维持自己的属性）

行为+状态

Python中类也称为类对象

Python中的self相当于C++中的self指针

dir(obj)可以获得对象的所有属性、方法

obj.__dict__ 获得对象的属性字典

pass 空语句/空类

Isinstance(obj,Student) 判断obj是否为Student的对象

类方法

类方法市从属于类对象的方法。用来表示类内的状态，无法被类的实例调用

类方法通过装饰器@classmethod来定义

定义格式如下：

@classmethod

Def 类方法名(cls [,形参列表]):

函数体

要点：

@classmethod必须位于方法上面一行

第一个cls必须有；cls指的就是类对象本身

调用类方法格式：“类名.类方法名(参数列表)”

类方法中访问实例属性和实例方法会导致错误

子类继承父类方法时，传入cls是子类对象，而非父类对象

类方法用来操作类属性；

实例方法用来操作实例属性；

类方法与静态方法中不能调用实例！

因为饼干可以调用模具的信息，但创建模具的时候并没有饼干的信息

静态方法

Python中允许定义，称为静态方法

静态方法在调用时需要通过类调用

静态方法通过装饰器@staticmethod来定义，格式如下：

@staticmethod

def 静态方法名([形参列表]):

函数体

方法无重载

Python的方法没有重载，若在类体中定义了多个重名的方法函数，则只有最后一个方法有效

原因：由于C++等编程语言不存在可变参数，故需要多个同名函数（参数的数量不同）来控制类的方法。而python有可变参数的存在，因此可以直接在一个方法内进行分支操作

方法的动态性