0.写在开头
本文为笔者学习python期间做的笔记，方便自己学习查看。笔者之前学过C和Java，因此本文适合有语言基础的同志快速上手python基本语法。
暂更至面向对象基础，因为笔者学到这里就被导师抓去实验室调参搭网络了emmmmm
有些地方可能有点格式上的错误，欢迎提出指正
1.判断语句和循环语句
1.1 if判断的基本格式
if 判断条件:
判断条件为 True，会执行的代码
判断条件为 True，会执行的代码
...
# 在python中使用缩进，代替代码的层级关系
1.2 if-else
if 判断条件:
判断条件为 True，会执行的代码
判断条件为 True，会执行的代码
...
else:
判断条件为False，会执行的代码
判断条件为False，会执行的代码
...
1.3 if elif 结构
if 判断条件1:
判断条件1成立，执行的代码
elif 判断条件2:
判断条件1不成立，判断条件2成立，会执行的代码
else:
判断条件1和判断条件2都不成立，执行的代码
1.4 while循环
while 判断条件:
判断条件成立，执行的代码
判断条件成立，执行的代码
...
1.5 for循环
for 变量 in 字符串：
代码
- range(n) 会生成 [ 0, n ) 的数据序列，不包含 n*
- range(a, b) 会生成 [ a, b ) 的数据序列，不包含 b*
2.容器：字符串、列表、元组、字典
2.1 字符串
-
原始字符串只需要在字符串前边加一个英文字母 r 即可
print(r'C:\Program Files\Intel\Wifi\Help') # C:\Program Files\Intel\Wifi\Help
-
find() 字符串查找
-
split(str=“”, num) 不带参数默认是以空格为分隔符切片字符串，如果
num参数有设置，则仅分隔num个子字符串，返回切片后的子字符串拼接的列表str5 = ' I Love LsgoGroup ' print(str5.strip().split()) # ['I', 'Love', 'LsgoGroup'] print(str5.strip().split('o')) # ['I L', 've Lsg', 'Gr', 'up']u = "www.baidu.com.cn" # 使用默认分隔符 print(u.split()) # ['www.baidu.com.cn'] # 以"."为分隔符 print((u.split('.'))) # ['www', 'baidu', 'com', 'cn'] # 分割0次 print((u.split(".", 0))) # ['www.baidu.com.cn'] # 分割一次 print((u.split(".", 1))) # ['www', 'baidu.com.cn'] # 分割两次 print(u.split(".", 2)) # ['www', 'baidu', 'com.cn'] # 分割两次，并取序列为1的项 print((u.split(".", 2)[1])) # baidu一个复杂的例子：
string = "hello boy<[www.baidu.com]>byebye" print(string.split('[')[1].split(']')[0]) # www.baidu.com print(string.split('[')[1].split(']')[0].split('.')) # ['www', 'baidu', 'com']
2.2 切片
- 定义：切片是指对操作对象截取其中一部分的操作。字符串、列表、元组都支持切片操作
- 语法：[ 起始 : 结束 : 步长 ] 其中，选取的区间从起始位开始，到结束位的前一位结束（不包含结束位本身），步长表示选取间隔。
my_str = 'hello'
my_str1 = my_str[2:4] #step(步长)如果是1，即默认值，可以不写。
#my_str1的值为'll'
2.3 列表
- 定义：列表是python中的一种数据类型，可以存放多个数据，列表中的数据可以是任意类型的
- 列表 list ，定义使用[]进行定义
# 定义空列表
my_list = [] # 法一
my_list = list() # 法二
- 列表内元素可以被修改
mylist = [1, 3.14, 'abcd']
print(mylist) #[1, 3.14, 'abcd']
mylist[2] = '1234'
print(mylist) #[1, 3.14, '1234']
2.3.1 列表的遍历
for i in my_list:
print(i)
2.3.2 列表添加数据
mylist = [1, 3.14, 'abcd']
# 列表.append(数据) 向列表的尾部追加数据
mylist.append('aa')
print(mylist)
# 列表.insert(下标，数据) 在指定的下标位置进行添加数据
mylist.insert(0, '牛')
print(mylist)
输出结果为
[1, 3.14, 'abcd', 'aa']
['牛', 1, 3.14, 'abcd', 'aa']
2.3.3 列表的查询
-
index() 根据数据值，查找元素所在下标
-
count() 统计出现次数
2.3.4 列表的删除
-
根据元素的数据值删除
- remove(数据值) 直接删除原列表中数据
-
根据下标删除
-
del 列表 [下标]
del mylist[2]
-
2.3.5 列表的排序
- 列表.sort() 直接在原列表中进行排序
# 想要对列表中的数据进行排序，前提是列表中的数据类型是一样的
mylist = [1, 5, 3, 10, 8, 2]
# 列表.sout() 直接在原列表中进行排序
mylist.sort()
# 逆序排序
mylist.sort(reverse=True)
2.3.6 列表和元组的区别
- 列表是动态数组，它们可变且可以重设长度（改变其内部元素的个数）
- 元组是静态数组，它们不可变，且其内部数据一旦创建便无法改变
- 元组缓存于Python运行时环境，这意味着我们每次使用元组时无须访问内核去分配内存
2.4 字典
-
字典中的数据由键值对组成
#变量info为字典类型 info = {'name':'班长'，'id':100,'sex':'男','address':'湖北武汉'}
2.4.1 字典的定义和访问
# 字典 dict 定义使用{}定义，是由键值对组成(key-value)
# 变量 = {key1:value1, key2:value2, ...} 一个key:value键值对是一个元素
# 1.定义空字典
my_dict = {}
my_dict1 = dict()
# 2.定义带数据的字典
my_dict2 = {'name': 'luckyNiu', 'age': '18', 'interest': ['学习', '打球']}
# 3.访问Value值，在字典中没有下标的概念，使用key值访问对应的value值
# 取年龄 18
print(my_dict2['age'])
# 取兴趣 打球
print(my_dict2['interest'][1])
-
字典 .get(key) 另外一种获取字典数据的方式
print(my_dict2.get('age'))
2.4.2 字典中添加和修改数据
2.4.3 字典中删除数据
- del 字典名[key] 根据key值删除数据
- 字典 .clear() 清空字典，删除所有字典对
- del 字典名 直接把字典删除，不能再次使用
2.4.4 字典中遍历数据
-
for循环直接遍历字典
# for循环体直接遍历数据，遍历字典的key值 for i in my_dict: print(i, my_dict[i]) -
获取所有key值 字典 .keys()
# 字典.keys() 获取字典中所有的key值，得到的类型是 dict_keys,该类型具有的特点是 # 1.可以使用list() 进行类型转换，即将其转换为列表类型 # 2.可以使用for循环进行遍历 result = my_dict2.keys() print(result, type(result)) for key in result: print(key)输出结果为
dict_keys(['name', 'age', 'interest']) <class 'dict_keys'> name age interest -
获取所有value值 字典 .values()
# 字典.values() 获取字典中所有的value值，得到的类型是 dict_values,该类型具有的特点是 # 1.可以使用list() 进行类型转换，即将其转换为列表类型 # 2.可以使用for循环进行遍历 -
获取所有键值对 字典 .items()
# 字典.items() 获取字典中所有的键值对，得到的类型是 dict_items,key value组成元组类型 # 1.可以使用list() 进行类型转换，即将其转换为列表类型 # 2.可以使用for循环进行遍历 result = my_dict2.items() print(result, type(result)) for item in result: print(item[0], item[1])输出结果为
dict_items([('name', 'luckyNiu'), ('age', '18'), ('interest', ['学习', '打球'])]) <class 'dict_items'> name luckyNiu age 18 interest ['学习', '打球']
3. 函数
3.1 函数基础
3.1.1 函数的定义和调用
-
定义函数格式如下 关键字 def
def 函数名(): 代码
3.1.2 函数的文档说明
- 快捷查看
-
函数的文档说明本质就是注释，只不过这个注释有特定的书写要求，要写在函数名字的下方
def func(): """ 打印 hello world """ print("hello world") # 查看函数文档注释可以使用 help(函数名) # help(print) help(func())
3.1.3 局部变量和全局变量
3.1.4 函数返回值
3.2 函数进阶
3.2.1 函数传参的两种形式
def func(a,b,c):
print(f"a: {a} ")
print("b:", b) #打印每个参数的值
print(f"c: {c} ")
# 位置传参，按照形参的位置顺序将实参的值传递给形参
# func(1,2,3)
# 关键字传参，指定实参给到哪个形参，注意点：关键字必须是函数的形参名
# func(a=10, b=1, c=2)
3.2.2 缺省参数
# 缺省参数，形参。在函数定义时，给形参一个默认值，这个形参就是缺省参数
# 注意点：缺省参数要写在普通参数的后面
# 在函数调用的时候，如果给缺省参数传递实参值，使用的是传递的实参值，如果没有传递，则用默认值
def func(a, b, c=10): # 形参c 称为缺省参数
print(f"a: {a} ")
print(f"b: {b} ")
print(f"c: {c} ")
func(1, 2)
输出结果为
a: 1
b: 2
c: 10
3.2.3 不定长参数
# 在形参前面加上*，该形参变为不定长元组形参，可以接受所有的位置实参，类型是元组
# 在形参前面加上**，该形参变为不定长字典形参，可以接受所有的关键字实参，类型是字典
def func(*args, **kwargs):
print(args)
print(kwargs)
func(1, 2, 3, 4, 5, 6)
func(a=1, b=2, c=3)
func(1, 2, 3, a=4, b=5, c=6)
输出结果为
(1, 2, 3, 4, 5, 6)
{}
()
{'a': 1, 'b': 2, 'c': 3}
(1, 2, 3)
{'a': 4, 'b': 5, 'c': 6}
3.3 拆包
- 容器中元组的个数需要和变量的个数保持一致
# 组包：将多个数据值，组成元组，给到一个变量
a = 1, 2, 3
print(a) # (1, 2, 3)
# 拆包：将容器的数据分别给到多个数据，需要注意——数据的个数和变量的个数要保持一致
b, c, d = a # 拆包
print(b, c, d)
my_dict = {'name': '牛家乐', 'age': '18'}
a, b = my_dict # 拆包
print(a, b)
输出结果为
(1, 2, 3)
1 2 3
name age
4. 面向对象基础
- 面向过程：注重的是过程
- 函数
- 面向对象：关注的是结果
- 封装 / 继承 / 多态（三大基础）
4.1 类和对象
面向对象编程的2个非常重要的概念：类和对象
对象是面向对象编程的核心，在使用对象的过程中，为了将具有共同特征和行为的一组对象抽象定义，提出了另外一个新的概念—类
-
类：
- 属性：事物的特征描述信息，用来描述某个特征“是什么”。
- 行为：事物的能力行动方案，用于说明事物“能做什么”
-
对象：某一个具体事物的存在
4.1.1 类的组成
- 类名
- 属性：特性—变量
- 方法：行为—函数
4.1.2 类的抽象
- 名词提炼法
- 所见即所得
4.1.3 类的定义
代码用狗类进行说明
类名:Dog(狗类)
属性:
姓名 name
年龄 age
...
方法:
吃 eat()
玩 play()
...
例
# 在python中，定义类使用关键字class，语法如下
"""
object 是所有的类基类，即最初始的类
类名：遵循大驼峰的命名规范
class 类名(object):
类中的代码
"""
# 定义方式一 （推荐）
class Dog(object):
pass
# 定义方式二
class Dog1(): # 括号中的内容可以不写
pass
# 定义方式三
class Dog3: # 括号也可以不写
pass
4.1.4 创建对象
# 定义类
class Dog(object):
# 在类中定义的函数，称为方法，函数的所有知识都可以使用
def play(self):
print('拆家')
pass
# 创建对象 变量 = 类名()
dog = Dog()
# 可以使用对象调用类中的方法 对象.方法名()
dog.play()
# 给对象添加属性 对象.属性名 = 属性值
dog.name = '大黄'
dog.age = 2
# 获取对象的属性值 对象.属性名
print(dog.name)
4.2 魔法方法
在python的类中，有一类方法，这类方法以两个下划线开头和两个下划线结尾，并且在满足某个特定条件的情况下，会自动调用。这类方法，称为魔法方法。
4.2.1 _ _init _ _()
- 调用时机：在创建对象之后，会立即调用。
- 作用：
- 用来给对象添加属性，给对象属性一个初始值(构造函数)
2. 代码的业务需求，每创建一个对象，都需要执行的代码可以写__init__()中
- 用来给对象添加属性，给对象属性一个初始值(构造函数)
__init__() 是 Python 类的构造函数，它在创建一个类的实例时调用，可以用于初始化该实例的属性。
在 Python 中，类中定义的函数第一个参数通常是 self，表示该方法是该类实例的方法，而不是类方法或静态方法。self 通常在类中的其他方法中使用，以引用该实例的属性或其他方法。
例如，下面是一个示例类和它的 __init__() 方法：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
上面的 Person 类定义了一个 __init__() 方法，该方法接受两个参数 name 和 age，并将它们分别赋值给实例属性 self.name 和 self.age。当创建 Person 类的实例时，__init__() 方法将在实例化过程中自动调用，并使用传递给它的参数初始化实例的属性。例如：
person1 = Person("Alice", 25)
print(person1.name) # 输出 "Alice"
print(person1.age) # 输出 25
4.2.2 self
在 Python 类中，self 代表当前对象实例本身，是一个特殊的参数，必须出现在每个方法的参数列表的第一个位置，即第一个参数必须是 self。通过使用 self，对象实例可以访问其自身的属性和方法。
例如，在类中定义一个实例属性 name，并通过 __init__ 方法初始化：
class Person:
def __init__(self, name):
self.name = name
在实例化对象时，self 代表该对象本身，我们可以给它的 name 属性赋值：
person = Person("Tom")
print(person.name) # 输出 "Tom"
在类的其他方法中也可以使用 self 访问对象实例的属性和方法，例如：
class Person:
def __init__(self, name):
self.name = name
def say_hello(self):
print(f"Hello, my name is {self.name}.")
person = Person("Tom")
person.say_hello() # 输出 "Hello, my name is Tom."
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
