python的基础学习笔记

1.python的起源

创始人：吉多范罗苏姆

2.python的应用领域

• 网络开发
• GUI开发
• 科学和数学
• 软件开发
• 系统管理

3.python的注释

单行注释：#
多行注释：‘’‘注释’‘’’
快捷键：CTRL + /

4.python的变量

python是弱语言类型，赋值不需要声明变量类型，会自动根据值来决定，只有在赋值之后才会生成变量

01 变量的赋值

a = 10
a,b = 10,20  # 同时赋值

02 变量的默认命名规则

具有一定的描述性
只能由下划线，字母，数字组成，不能以数字开头
默认驼峰式命名规则或者下划线分割单词
区分大小写

5.python的数据类型

01 字符串类型

单引号,双引号或者三引号引用的对象称之为字符串，并且存在引号错开使用【内单外双，内双外单】
三引号一般用于多行注释
属于序列，存在索引和切片的特性

1-1 字符串的拼接

a = '123'
b = 'li'
print(a+b)  # 输出：123li
print(a*3)  # 输出：123123123

1-2 索引

字符串的下标从0开始，最大的下标为字符串的长度-1，使用负数表达时，最后一个的索引为-1

1-3 字符串的取值

通过索引进行取值

a = '1dfrgth'
print(a[-1]) # 获取字符串的最后一个值

1-4 字符串的切片操作

语法：str1[开始位置，终止位置，步长]【可以正向/反向切片】

a = '1dfrgth'
print(a[2,5]) # 获取从2个到第5个的字符串片段，不包括第5个字符---frg

1-5 字符串的一些方法

isdigit() 是否是纯数字
isalpha() 是否是纯字母
find(‘元素’,开始位置) 寻找字符串中元素出现的索引位置，找不到返回-1
index(‘元素’,开始位置) 寻找字符串中元素出现的索引位置，找不到程序报错
strip() 清除字符串的前后空格，加入参数元素，表示去除字符串两边指定的元素
replace() 使用元素替代字符串的某些元素或者字段
startswith() 判断是否以指定的元素开头
endswith() 判断是否以指定元素结尾

str1 = 'duehielaauka'
print(str1.isdigit())  # 输出：False【判断该字符串中是否全部是数字--->True/False】

print(str1.isalpha())  # 输出：True 【判断字符串中是否全是字母 ---> True/False】

print(str1.find('u'))  # 输出：1【寻找字符串中元素第一次出现的索引位置】
print(str1.find('u', 5))  # 输出：9【5表示寻找的开始位置】
print(str1.find('y', 5))  # 输出：-1   【找不到返回-1】

print(str1.index('u'))  # 输出1【寻找字符串中元素第一次出现的索引位置】
print(str1.index('u', 5))  # 输出9【5表示寻找的开始位置】
# print(str1.index('y'))  # 找不到，程序会直接报错

str2 = '   sdsjowjow '
print(str2.strip())  # 输出：sdsjowjow【去除字符串左右两边的空格】
print(str2.lstrip())  # 输出：sdsjowjow 【去除字符串左边的空格】
print(str2.rstrip())  # 输出：   sdsjowjow 【去除字符串右边的空格】

str3 = '***ndjd**ndj***'
print(str3.strip("*"))  # 输出ndjd**ndj【去除字符串两边指定的字符】

print(str3.replace("*", "&"))  # 输出：&&&ndjd&&ndj&&&【替换字符串中的对应字符】

print(str3.startswith("**"))  # 输出：True【判断字符串是否以*开头】
print(str3.startswith("0"))  # 输出：False【判断字符串是否以*开头】

print(str3.endswith("0"))  # 输出：False【判断字符串是否以0结尾】

print(str3.split("*"))  # 输出：['', '', '', 'ndjd', '', 'ndj', '', '', '']【以*为分隔符切割字符串，以列表数据类型返回】

1-6 字符串的格式化操作

name = 'lily'
age = 18
height = 166.98
print('姓名：' + name + ',年龄：' + str(age))  # 输出：姓名：lily,年龄：18

# 格式化字符串方式一【使用占位符】
'''
%s  字符串
%d  有符号的十进制数
%f  浮点数 %.2f表示保留的小数位数
%x  无符号的十六进制数(小写)
%X  无符号的十六进制数(大写)
'''
print('姓名：%s,年龄：%d,身高：%.2f' % (name, age, height))  # 输出：姓名：lily,年龄：18,身高：166.98

# 格式化字符串方式二【使用{}.format()格式】
print('姓名：{:*>10},年龄：{},身高：{}'.format(name, age,
                                            height))  # 输出：姓名：******lily,年龄：18,身高：166.98【{}可以使用下标进行填值，也可以控制补齐和对齐】
# {:*>10}表示用*补齐指定长度10位，>表示右对齐【<左对齐；>表示右对齐；^表示居中对齐】【字符串默认左对齐，数字默认右对齐】

# 格式化字符串方式三【f''】
print(f'姓名：{name:*>10},年龄：{age},身高：{height}')  # 输出：姓名：******lily,年龄：18,身高：166.98

02 列表类型

列表也属于序列，存在索引和切片操作[和字符串类似]，而且列表的数据类型可以是任意类型

2-1 列表的一些方法操作

list1 = [1, 2, 3, 4, [1, 2]]
list1.append('python')  # 列表的增加，默认添加到列表的末尾
print(list1)  # 输出：[1, 2, 3, 4, [1, 2], 'python']
list1[-1] = 'python01'  # 列表的元素修改
print(list1)  # 输出：[1, 2, 3, 4, [1, 2], 'python01']
list1.insert(0, 'index_001')  # 指定位置添加元素到列表中
print(list1)  # 输出：['index_001', 1, 2, 3, 4, [1, 2], 'python01']
list1.pop()  # 不指定，默认删除列表的最后一位
print(list1)  # 输出：['index_001', 1, 2, 3, 4, [1, 2]]
list1.pop(1)  # 删除指定的索引位置的值
print(list1)  # ['index_001', 2, 3, 4, [1, 2]]
# pop()方法删除会返回删除的元素本身
list1.remove('index_001')  # 根据元素的值删除列表元素[当存在多个相同的元素，默认删除第一个元素]
print(list1)  # 输出：[2, 3, 4, [1, 2]]
del list1[0]  # 删除指定的索引位置的值
print(list1)  # 输出：[3, 4, [1, 2]]
list1.clear()  # 清空列表
print(list1)  # 输出：[]
del list1  # 直接删除列表
# print(list1)  # 输出：直接报错 ---> NameError: name 'list1' is not defined

2-2 列表的拼接

list2 = [1, 23]
list3 = [1, 34, 'sn']
list2.extend(list3)  # 列表的拼接
print(list2, list3)  # 输出：[1, 23, 1, 34, 'sn'] [1, 34, 'sn']

2-3 深拷贝和浅拷贝

列表的赋值相当于给列表起了一个别名，不会胜场新的对象，内存地址也不会发生改变
浅拷贝会生成一个新的对象，但是子列表依旧是同一个内存地址
深拷贝会生成一个新的对象，同时子列表也是一个新的列表对象

list1 = [1, 2, 3, [1, 2, 3]]
list2 = list1  # 直接赋值
print(id(list1), id(list2))  # 输出：2612728743616 2612728743616【赋值不会生成新的对象，内存地址不会发生改变】
list1[0] = 100
print(list1, list2)  # 输出：[100, 2, 3, [1, 2, 3]] [100, 2, 3, [1, 2, 3]]【赋值的状态下修改其中任意一个，另一个也会随之发生改变】

# 生成新的对象/列表，但是子列表还是同一个内存地址
import copy

list3 = copy.copy(list1)
print(id(list1), id(list3), id(list1[-1]), id(
    list3[-1]))  # 输出：2321593059008 2321594318464 2815409139776 2815409139776【浅拷贝会生成新的对象，内存地址会发生改变;但是内部的列表的内存地址是一样的】
list1[0] = 200
print(list1, list3)  # 输出：[200, 2, 3, [1, 2, 3]] [100, 2, 3, [1, 2, 3]]【浅拷贝状态下修改任意一个，另一个不会随之发生改变】
list1[-1][-1] = 100
print(list1, list3)  # 输出：[200, 2, 3, [1, 2, 100]] [100, 2, 3, [1, 2, 100]]   【浅拷贝状态下修改内嵌列表的任意一个，另一个也会随之发生改变】

# 深拷贝：生成新对象，同时子列表也生成了新的列表对象
from copy import deepcopy

list4 = copy.deepcopy(list1)
print(id(list1), id(list4), id(list1[-1]), id(
    list4[-1]))  # 输出：1269531854528 1269537335744 1269531816064 1269537227392【深拷贝会生成新的对象，子列表也是一个新的对象】
list1[0] = 300
print(list1, list4)   # 输出：[200, 2, 3, [1, 2, 100]] [200, 2, 3, [1, 2, 100]]
list1[-1][-1] = 300
print(list1, list4) # 输出：[300, 2, 3, [1, 2, 300]] [200, 2, 3, [1, 2, 100]]

03 元组类型

元组也是一个序列，可以进行索引和切片操作；但是元组的元素是不可变的，不能进行元素的修改等操作

04 布尔值

布尔值有两个值【True/False】【True可以用1表示，False可以用0表示，在参与运算时可以进行换算】

4-1 布尔表达式

== != <= >= < >
字符串之间的比较实质上是ASCII码的比较

05 字典

以键值对格式成对存在
元素可以改变，键是不可变对象，唯一的，但是值可以是任意类型的数据

5-1 字典的增删改

dict1 = {"name": 'lily', 'age': 18, 'sex': "man"}
# 更新
dict1.update({"name": "lily01", "score": 90})  # 存在的就是修改,不存在的就是新增
dict1['age'] = 90
print(dict1)  # 输出:{'name': 'lily01', 'age': 90, 'sex': 'man', 'score': 90}

dict1.pop('age')
print(dict1)  # 字典的删除  输出:{'name': 'lily01', 'sex': 'man', 'score': 90}

del dict1['sex']  # 字典的删除  输出:{'name': 'lily01', 'score': 90}
print(dict1)

dict1.clear()
print(dict1)  # 字典的清空 输出:{}

5-2 字典的遍历

# 字典的遍历
dict2 = {'name': 'lily01', 'age': 90, 'sex': 'man', 'score': 90}
for key, value in dict2.items():  # 遍历键和值
    print(key, value)
for key in dict2.keys():  # 遍历键
    print(key)

for value in dict2.values(): # 遍历值
    print(value)

6.python的运算符

01 xx运算符

and not or
优先级：not > and > or【当然括号可以改变优先级】
遵循的原则：and【全真为真，一假为假】 or【一真为真，全假为假】 not【直接反过来即可】

7.python的转义符

换行符：\n
规避转移/不希望被转移：\或者在字符串前面加上r表示后面的字符串的转义符不会进行转义

8.python的条件判断

01 if条件判断

# if语句的条件判断
num1 = 20
if num1 >= 20:  # if语句的条件
    print("该数字大于等于20")  # 输出：该数字大于等于20  【条件满足时，则会执行该缩进语块】
else:
    print("该数字小于20")  # 【条件不满足时，执行的语句块】

02 多个分支条件

分支之间是相互互斥

# 多个分支条件
num1 = 101
if num1 <= 20:  # if语句的条件
    print("该数字小于等于20")  # 输出：该数字大于等于20  【条件满足时，则会执行该缩进语块】
elif num1 <= 50:
    print("该数字在20-50之间(包括50但是不包括20)")
elif num1 <= 100:
    print("该数字在50-100之间(包括100但是不包括50)")
else:
    print("该数字大于100")

03 条件判断语句的嵌套

# 条件判断语句的嵌套
age = 90
if age >= 18:
    if age <= 30:
        print("青年")
    elif age <= 50:
        print("中年")
    else:
        print("老年")
else:
    print("未成年")

9.python中的函数

是一段代码的组合，用来实现一定的功能，方便后期的复用

01 内置函数

print()
int()
str()
len()
float()
…
直接调用不需要定义

# 内置函数
print('hello')
s1 = '123'
print(len(s1))
print(int(s1))
# ......

02 自定义函数

遵循先定义再调用的顺序，而且函数的定义不会执行

# 自定义函数
def fun1():  # 函数的定义[def 函数名称(一般函数名称建议见名知义):]
    print("自定义函数功能")


fun1()  # 函数的调用

03 函数的参数

参数：形参和实参

# 函数的参数
def fun1(a, b):  # a,b为形参
    print(a + b)
    
fun1(2, 9)  # 输出：11【2，9表示实参】

# 可变长度参数 *args
def fun4(a, *args):
    return a, *args  # *args称之为解包


print(fun4(1, 2, 3))  # 输出：(1,)【以元素的类型返回】

# 关键字参数 **kwargs
def fun5(**kwargs):
    return kwargs


print(fun5(name='name001'))  # 输出：{'name': 'name001'}【传参方式以键值对方式，以字典的类型返回】

04 函数的参数的缺省值【默认值】

# 函数的默认值
def fun2(a=1, b=89):
    print(a + b)


fun2()  # 不输入实参，直接传入默认的值
fun2(13, 19)  # 输入实参，则根据输入的进行输出【省略写法】
fun2(50)  # 存在默认，只写一个默认对应第一个
fun2(b=23)  # 指定特定的参数
fun2(b=23, a=10)  # 完整的写法
# fun2(b=23, 300)  # 不可以先完整写法，再省略写法，会报错

05 函数的返回值

关键字：return
return之后表示退出函数，后面的语句不再执行

# 函数的返回值
def fun3(a, b):
    return a + b, a - b  # 可以返回一个或者多个 【调用函数后返回的值】


print(fun3(2, 10))  # 输出：(12, -8)【多个值返回的数据类型默认为元组类型】

10 python的循环

01 while循环

# while循环
n = 1
while n <= 10:
    print(n)
    n += 1

02 for循环

for循环一般会结合range()函数进行使用
range(开始位置，结束位置，步长)【左开右闭】

# for循环
for i in range(1, 11):
    print(i)

03 break，continue

continue表示终止本轮循环
break表示跳出整个循环

# break,continue
for i in 'python':
    if i == 'o':  # 当i==’o'时跳出整个循环
        break
    print(i, end='')  # 输出：pyth

for i in 'python':
    if i == 'o':  # 当i==‘o'时，终止本轮循环
        continue
    print(i, end='')  # 输出：pythn

04 for…else语句

# for...else语句
for i in range(1, 10):
    if i == 9:
        break
    print(i)
else:
    print('执行结束')

11.文件的读写

01 文件读取内容的方式

with open('demo.txt', encoding='utf-8') as fo:
    # print(fo.read())  # 读取文件内容，以字符串类型返回
    print(fo.readline())  # 读取文件的第一行内容
    # print(fo.readlines())  # 一行一行读取文本内容，以列表的方式返回，但是存在换行符
    # print(fo.read().splitlines())  # 一行一行读取文本内容，以列表的方式返回也不存在换行符

02 文件读取的指针问题

seek(0)
获取指针的位置：print(fo.tell())

03 文件的读写模式

r+ 可以同时读写文件，找不到文件时报错，覆盖写入
w+ 同时读写文件，找不到文件时新建，属于清空写入
a+ 可以同时读写文件，找不到文件时新建，属于追加写入

with open('demo.txt', 'a+', encoding='utf-8') as fo:
    '''
    r+ 覆盖写入
    w+ 清空写入
    a+ 追加写入
    '''
    # print(fo.read())  # 读取文件内容，以字符串类型返回
    print(fo.readline())  # 读取文件的第一行内容
    fo.seek(0)  # 指针回到文件起点
    print(fo.readlines())  # 一行一行读取文本内容，以列表的方式返回，但是存在换行符
    # print(fo.read().splitlines())  # 一行一行读取文本内容，以列表的方式返回也不存在换行符
    fo.write('123')
    fo.seek(0)
    print(fo.read())

12.json格式

字符串类型，键值对搁置，里面的元素在python中必须使用双引号

12-1 字典与json之间的转换

import json

json1 = '{"name": "lily", "age": 19}'
print(type(json1))  # 输出:<class 'str'>

dict1 = {"name": "lily", "age": 19}
print(type(dict1))  # 输出:<class 'dict'>

# 字典转json格式
j2 = json.dumps(dict1)
print(type(j2), j2)  # 输出:<class 'str'> {"name": "lily", "age": 19}

# json格式转字典
d2 = json.loads(json1)
print(type(d2), d2)  # 输出:<class 'dict'> {'name': 'lily', 'age': 19}

13.yaml文件操作

一种用于写配置文件的语言，简介强大，属于一种标记语言，扩展名称为.yaml或者.yml
yaml文件读取需要依赖第三方库（pyyaml）

13-1 yaml文件

# 字典格式
name1: name001
name2: 'name002'
name3: "name003"
url: &host 123  # 定义变量
host: *host # 变量的引用
--- # 不同类型需要添加的分隔符
# 列表格式
- [ 1,2,3 ]
-
  - [ 4,5,6 ]
  - name: lily

13-2 yaml文件的读取

import yaml  # 需要下载【pip install pyyaml (-i 镜像源)】

with open("demo.yaml", encoding='utf-8') as fo:
    # text = yaml.load(fo,Loader=yaml.FullLoader) # 单个数据类型的yaml文件读取
    text = yaml.load_all(fo, Loader=yaml.FullLoader) # 多个不同类型数据的yaml文件
    print(type(text)) # <class 'generator'>【迭代器类型】
    for i in text:
        print(i)

14.面向对象

# 定义类【class 类名:】
class Rectangle:
    classname = 'rectangle'  # 类属性/类变量

    def __init__(self, width, length):  # 实例属性-width,length
        '''
        __init__方法用于在创建对象时进行初始化操作
        :param width:
        :param length:
        '''
        self.width = width
        self.length = length

    def perimeter(self):  # 实例方法
        return (self.length + self.width) * 2

    def area(self):  # 实例方法
        return self.length * self.width
        
    @classmethod
    def fun01(cls): # 使用@classmethod申明该方法为类方法，可以被实例或者类调用
        return '长方形'
        
    @staticmethod
    def fun02(): # 使用@staicmethod申明该方法为静态方法，本质上和类是没有直接的关系【实例和类都可以调用静态方法】
        return '静态方法'
    @property
    def fun03(self): # 使用@property申明该方法转为属性
        print("方法转属性")
        
# 实例化【类名(参数)】【类不能直接调用实例的方法】
rectangle = Rectangle(2, 8)  # 产生具体的对象

# 对象的调用
print(f'类名：{rectangle.classname}')
print(f'周长:{rectangle.perimeter()}')
print(f'面积：{rectangle.area()}')

print(f'使用实例调用类方法：{rectangle.fun01()}')
print(f'使用类调用类方法：{Rectangle.fun01()}')

print(f'使用实例调用静态方法：{rectangle.fun02()}')
print(f'使用类调用静态方法：{Rectangle.fun02()}')
import inspect
print(inspect.ismethod(rectangle.fun02))  # 不是方法
print(inspect.ismethod(rectangle.fun01))  # 是方法

rectangle.fun03  # 直接使用属性的方式进行

14-1 面向对象继承

实现了代码的复用性

01 单继承

class Rectangle:
    classname = 'rectangle'  # 类属性/类变量

    def __init__(self, width, length):  # 实例属性-width,length
        '''
        __init__方法用于在创建对象时进行初始化操作
        :param width:
        :param length:
        '''
        self.width = width
        self.length = length

    def perimeter(self):  # 实例方法
        return (self.length + self.width) * 2

    def area(self):  # 实例方法
        return self.length * self.width

    @classmethod
    def fun01(cls):
        return '长方形'

    @staticmethod
    def fun02():  # 使用@staicmethod申明该方法为静态方法，本质上和类是没有直接的关系【实例和类都可以调用静态方法】
        return '静态方法'


class Square(Rectangle):  # 继承于Rectangle类【完全继承/部分继承】
    def __init__(self, side):  # 方法的重写
        # self.width = side
        # self.length = side
        super().__init__(side, side)  # 调用父类的一个方法

    @classmethod
    def fun01(cls):  # 继承并追加
        print("正方形")
        return super().fun01()


square = Square(8)
print(f'正方形的面积：{square.area()}')
print(f'正方形的周长：{square.perimeter()}')
print(square.fun01())

02 多继承

一个子类可以有多个继承
当父类具有相同的方法或者属性，执行时会根据继承的顺序继承

class Monkey:
    def __int__(self):
        pass

    def eat(self):
        print("猴子会吃香蕉")

    def shut(self):
        print("猴子会叫")


class Gods:
    def __int__(self):
        pass

    def fly(self):
        print("神仙会飞")

    def eat(self):
        print("神仙喝露水")


class Swk(Gods, Monkey):  # 多继承，继承Monkey和Gods类
    pass


swk = Swk()
swk.fly()
swk.eat()  # 输出：神仙喝露水【按照继承顺序】