Python基础学习笔记

眼眸流转

已于 2023-02-07 15:45:21 修改

阅读量279

点赞数 1

分类专栏： python 文章标签： python

于 2023-01-10 17:43:46 首次发布

本文链接：https://blog.csdn.net/gyfghh/article/details/128633924

版权

python 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Python基础学习笔记

1、环境配置

1.1、下载

python官网：https://www.python.org/downloads/
在这里插入图片描述

1.2、安装

在这里插入图片描述

1.3、验证

在这里插入图片描述

2、快速入门

print("hello world!")

3、注释

# 这是单行注释

"""
	这是多行注释
"""

4、变量

money = 30
print(money)
money -= 10
print(money)

5、数据类型

5.1、基础数据类型

# 整数
let1 = 10
print(let1)
# 浮点数
let2 = 30.65
print(let2)
# 布尔
let3 = False
print(let3)
# 字符串
let4 = "风华"
print(let4)
# 数组
let5 = ['a', 'b', 'c']
print(let5)
# 元组
let6 = ('a', 'b', 'c')
print(let6)
# 集合
let7 = {'a', 'b', 'c'}
print(let7)
# 字典
let8 = {'语文': 89, '数学': 92, '英语': 93}
print(let8)

5.2、数据类型转换

函数	作用
int(x)	将 x 转换成整数类型
float(x)	将 x 转换成浮点数类型
str(x)	将 x 转换为字符串
repr(x)	将 x 转换为表达式字符串
eval(str)	计算在字符串中的有效 Python 表达式，并返回一个对象
chr(x)	将整数 x 转换为一个字符
ord(x)	将一个字符 x 转换为它对应的整数值
hex(x)	将一个整数 x 转换为一个十六进制字符串
oct(x)	将一个整数 x 转换为一个八进制的字符串

5.3、字符串

1、定义方式

str1='风华'
str2="风华"
str3="""风华
        123134123
        2313131"""
print(str1)
print(str2)
print(str3)

2、字符串拼接

str1 = '风华'
str2 = "风华"
# 字符串拼接
print(str1 + str2)

占位拼接

%s：作为字符串拼接
%d：作为整数拼接
- %md：m填写数字可控制宽度
%f：作为浮点数拼接
- %m.nf：m填写数字可控制宽度(整数部分+小数点+小数部分)，n控制小数部分精度

str1 = '风华'
num1 = 10
num2 = 19.9
# 占位拼接
print(str1 + "%s" % num1)
print(str1 + "#%3d -%7.3f" % (num1, num2))

快速写法

str1 = '风华'
num1 = 10
num2 = 19.9
# 字符串与其他类型拼接
# print(str1 + num1) 错误
# 快速拼接
print(f"{str1} {num1} - {num2}")
print(f"{str1} {num2 * num1}")

3、常用方法

str = " 百 炼 成 钢 绕 指 柔 "
str1 = "321百炼成12321钢绕指柔12321"

# 通过下标取字符
print(str[1])
print(str[-2])
# 查找子字符串在字符串中的下标
print(str.index("钢"))
# 替换字符串中指定子字符串
print(str.replace("钢","gang"))
# 用指定字符分割字符串
print(str.split(' '))
# 去除字符串前后空格
print(str.strip())
# 去除字符串前后指定字符
print(str1.strip("123"))
# 统计字符串中子字符串出现次数
print(str1.count("123"))
# 统计字符串长度
print(len(str1))

4、遍历

str = "321百炼成12321钢绕指柔12321"

i=0
while i<len(str):
    print(str[i])
    i+=1

str = "321百炼成12321钢绕指柔12321"

for i in str:
    print(i)

6、算数运算符

运算符	说明	实例	结果
+	加	12.45 + 15	27.45
-	减	4.56 - 0.26	4.3
*	乘	5 * 3.6	18.0
/	除法（和数学中的规则一样）	7 / 2	3.5
//	整除（只保留商的整数部分）	7 // 2	3
%	取余，即返回除法的余数	7 % 2	1
**	幂运算/次方运算，即返回 x 的 y 次方	2 ** 4	16，即 24

# 加法
print("1 + 1 =", 1 + 1)
# 减法
print("1 - 1 =", 1 - 1)
# 乘法
print("5 * 2 = ",5 * 2)
# 除法
print("5 / 2 = ",5 / 2)
# 取整除法
print("5 // 2 = ",5 // 2)
# 取余
print("5 % 2 = ",5 % 2)
# 指数
print("5 ** 2 = ",5 ** 2)

7、数据输入

print("who are you?")
print(f"hello,{input()}")

print(f"hello,{input('who are you?')}")
print(f"thanks,{type(input('how old are you?'))}")

8、比较运算符

比较运算符	说明
>	大于，如果`>`前面的值大于后面的值，则返回 True，否则返回 False。
<	小于，如果`<`前面的值小于后面的值，则返回 True，否则返回 False。
==	等于，如果`==`两边的值相等，则返回 True，否则返回 False。
>=	大于等于（等价于数学中的 ≥），如果`>=`前面的值大于或者等于后面的值，则返回 True，否则返回 False。
<=	小于等于（等价于数学中的 ≤），如果`<=`前面的值小于或者等于后面的值，则返回 True，否则返回 False。
!=	不等于（等价于数学中的 ≠），如果`!=`两边的值不相等，则返回 True，否则返回 False。
is	判断两个变量所引用的对象是否相同，如果相同则返回 True，否则返回 False。
is not	判断两个变量所引用的对象是否不相同，如果不相同则返回 True，否则返回 False。

print(f"1>2?{1 > 2}")
print(f"1<2?{1 < 2}")
print(f"3>=2?{3 >= 2}")
print(f"3<=2?{3 <= 2}")
print(f"3==2?{3 == 2}")
print(f"'xumeng'=='xumeng'?{'xumeng'=='xumeng'}")

9、流程控制

9.1、分支语句

1、if-else

单if

age = int(input("your age:"))
if age > 18:
    print("You are an adult")

if-else

age = int(input("your age:"))
if age > 18:
    print("You are an adult")
else:
    print("You are not yet of age")

If-elif-else

score = int(input("your score:"))
if 0 <= score < 60:
    print("fail")
elif 60 <= score < 80:
    print("pass")
elif 80 <= score <= 100:
    print("excellent")
else:
    print("invalid")

嵌套

score = int(input("your score:"))
if 0 <= score < 100:
    print("Valid！")
    if score >= 60:
        print("passed")
    else:
        print("failed")
else:
    print("invalid!")

9.2、循环

1、while循环

1+…100

num = 1
result = 0
while num <= 100:
    result += num
    num += 1
print("1+.....100 =", result)

1+…50

num = 1
result = 0
while num <= 100:
    result += num
    num += 1
    if num == 50:
        break
print("1+.....50 =", result)

1+…49+51+…100

num = 0
result = 0
while num < 100:
    num += 1
    if num == 50:
        continue
    result += num
    print(result)
print("1+.....49+51+.....100 =", result)

九九乘法表

i = 1
while i <= 9:
    j = 1
    while j <= i:
        print(i * j, end=" ")
        j += 1
    print()
    i += 1

2、for循环

forin

name="xumeng"
for c in name:
    print(c)

range

num = 0
result = 0
# range(101):获取0-100的整数
for i in range(101):
    result += i
print(result)
result = 0
# range(1，101):获取1-100的整数
for i in range(101):
    result += i
print(result)
result = 0
# range(1，101):获取1-100的奇数
for i in range(1, 101, 2):
    result += i
print(result)
result = 0
# range(1，101):获取1-100的偶数
for i in range(0, 101, 2):
    result += i
print(result)

九九乘法表

for i in range(1, 10):
    for j in range(1, i + 1):
        print(i * j, end=" ")
    print()

10、函数

10.1、函数基础

def myadd(a, b):
    return a + b


print(myadd(1, 1))

10.2、函数进阶

1、多返回值

def myAdd_myReduce(a, b):
    return a + b, a - b


sum, difference = myAdd_myReduce(2, 1)
print(sum, difference)

2、函数传参方式

位置参数

def introduce(name, age, address):
    print(f"大家好 我的名字是{name},今年{age}岁了 来自{address}")


introduce("张三", 22, "河南南阳")

关键字传参

def introduce(name, age, address):
    print(f"大家好 我的名字是{name},今年{age}岁了 来自{address}")


introduce(name="张三", address="河南南阳", age=22)

# 位置参数和关键字传参混合使用，位置参数必须在前面
def introduce(name, age, address):
    print(f"大家好 我的名字是{name},今年{age}岁了 来自{address}")


introduce("张三", address="河南南阳", age=22)

缺省参数

缺省参数必须位于位置参数后

def introduce(name, age, address="中国"):
    print(f"大家好 我的名字是{name},今年{age}岁了 来自{address}")


introduce("张三", address="河南南阳", age=22)
introduce("李四", age=22)
introduce("王五", 22)

不定长参数

def introduce(name, age, address, *args):
    print(f"大家好 我的名字是{name},今年{age}岁了 来自{address} 爱好是{args}")


introduce("张三", "河南南阳", 22, "打篮球", "踢足球", "乒乓球")

def introduce(name, age, address, **kwargs):
    print(f"大家好 我的名字是{name},今年{age}岁了 来自{address} 爱好是{kwargs} 喜欢的球类运动是{kwargs['ball']} 喜欢的书是{kwargs['book']}")


introduce("张三", "河南南阳", 22, ball="打篮球", book="Erlang")

函数参数

def computed(fun, a=2, b=3):
    fun(a, b)


def fun1(a, b):
    print(a + b)


def fun2(a, b):
    print(a * b)


computed(fun1, 7, 8)
computed(fun2)

3、匿名函数

def computed(fun, a=2, b=3):
    print(fun(a, b))


computed(lambda a, b: a + b, 7, 8)
computed((lambda a, b: a * b))

11、数据容器

通用方法

len(容器)：统计容器长度
max(容器)：统计容器最大元素
min(容器)：统计容器最小元素
list(容器)：将指定容器转为数组
str(容器)：将指定容器转为字符串
tuple(容器)：将指定容器转为元组
set(容器)：将指定容器转为集合
sorted(容器,[bool reverse])：将指定容器进行排序

11.1、数组

1、定义

name_list = ['zhangsna', 'lisi', 'wangwu']
age_list = list(11, 23, 45)

2、常用方法

name_list = ['zhangsan', 'lisi', 'wangwu']

# 根据索引取元素
print(name_list[0])
# 根据元素取索引
print(name_list.index('zhangsan'))
# 修改元素
name_list[0] = 'zhangsan1'
print(name_list)
# 插入元素
name_list.insert(0, 'zhaoliu')
print(name_list)
# 追加元素
name_list.append('qianqi')
print(name_list)
# 追加元素（批量）
name_list.extend(['xiaoming', 'xiaohong', 'xiaolan'])
print(name_list)
# 删除元素（索引）
del name_list[0]
print(name_list)
pop = name_list.pop(0)
print(name_list)
print(pop)
# 删除元素（元素）
name_list.insert(0, 'lisi')
print(name_list)
name_list.remove('lisi')
print(name_list)
# 清空
name_list.clear()
# count
name_list = ['lisi', 'lisi', 'wangwu', 'qianqi', 'xiaoming', 'xiaohong', 'xiaolan']
print(name_list.count('lisi'))
# 数组长度
print(len(name_list))

3、遍历

name_list = ['zhangsan', 'lisi', 'wangwu']
i = 0
while i < len(name_list):
    print(name_list[i])
    i += 1

name_list = ['zhangsan', 'lisi', 'wangwu']
for i in name_list:
    print(i)

11.2、元组

元组定义完成不可被修改,但其内部若存在数组,数组内的内容仍可改变

1、定义

name_tuple = ('zhangsan', 'lisi', 'wangwu')
age_tuple = tuple(11, 23, 45)
# name_tuple = ('zhangsan') 错误写法，单个元素应在后面加,
name_tuple1 = ('zhangsan',)

2、常用方法

name_tuple = ('zhangsan', 'lisi', 'wangwu', 'lisi')

# 根据索引取元素
print(name_tuple[0])
# 查找指定元素下表
print(name_tuple.index("lisi"))
# 计算元素出现次数
print(name_tuple.count("lisi"))
# 元组元素个数
print(len(name_tuple))

3、遍历

name_tuple = ('zhangsan', 'lisi', 'wangwu')

i = 0
while i < len(name_tuple):
    print(name_tuple[i])
    i += 1

name_tuple = ('zhangsan', 'lisi', 'wangwu')

for i in name_tuple:
    print(i)

11.3、序列

定义：内容连续、有序、可以使用下标索引的一类数据容器

字符串、数组、元组都是序列

1、切片操作

从一个序列中取出一个子序列

name_list = ["0", "1", "2", "3", "4", "5", "6"]
age_tuple = (0, 1, 2, 3, 4, 5, 6)
str = "0123456"


def mySplit(sequence):
    print("====================")
    print(sequence[:])  # 不写默认复制
    print(sequence[1:])  # 结束坐标不写默认到结尾
    print(sequence[:2])  # 开始坐标不写默认为开始
    print(sequence[1:4])  # 指定开始结束坐标
    print(sequence[1::1])  # 指定步长,为1表示一个一个取
    print(sequence[1:5:1])
    print(sequence[::2])  # 指定步长,为N(N为正整数，且大于1),每次跳过N-1个元素取;
    print(sequence[::-1])  # 指定步长,为负数,反向取(此时开始下标结束下标也应为负数)
    print(sequence[-1:len(sequence) * -1:-1])


# 数组切片
mySplit(name_list)
# 元组
mySplit(age_tuple)
# 字符串
mySplit(str)

11.4、集合（set）

元素不可重复，内容无序

1、定义

book_set = {"JAVA基础", "JAVA WEB", "SPRING", "SPRING", "SPRING BOOT", "SPRING CLOUD"}
book_set1 = set("ABCDEFG")
print(book_set)
print(book_set1)

2、常用方法

book_set = {"JAVA基础", "JAVA WEB", "SPRING", "SPRING", "SPRING BOOT", "SPRING CLOUD"}
print(book_set)

# 添加元素
book_set.add("HTML5")
print(book_set)
# 删除元素
book_set.remove("JAVA WEB")
print(book_set)
# 随机取出一个元素
print(book_set.pop())
# 清空集合
book_set.clear()
print(book_set)
# 获取两个集合差集(a集合有的，b集合没有的，得到新的集合)
num1_set = {1, 2, 3, 4, 5}
num2_set = {2, 3, 9}
print(num1_set.difference(num2_set))
# 消除两个集合差集(删除a集合中与b集合相同的元素，a集合改变，b集合不变)
num1_set.difference_update(num2_set)
print(num1_set)
# 合并两个集合(得到新的集合)
num1_set = {1, 2, 3, 4, 5}
num2_set = {2, 3, 9}
print(num1_set.union(num2_set))
# 统计集合个数
print(len(num1_set))

3、遍历

book_set = {"JAVA基础", "JAVA WEB", "SPRING", "SPRING", "SPRING BOOT", "SPRING CLOUD"}

for i in book_set:
    print(i)

11.5、字典

Key:value格式，key不可重复，字典可以嵌套

1、定义

achievement = {
    "zhangsan": 90,
    "lisi": 59,
    "wangwu": 85,
    "zhaoliu": 99
}
achievement1=dict()
print(achievement)
print(achievement1)

2、常用方法

achievement = {
    "zhangsan": 90,
    "lisi": 59,
    "wangwu": 85,
    "zhaoliu": 99
}

# 根据key取value值
print(achievement["zhangsan"])
# 新增/更新元素(元素不存在为新增，元素存在则为更新)
achievement["qianqi"] = 100
print(achievement)
# 删除元素
achievement.pop("zhangsan")
print(achievement)
# 清空字典
achievement.clear()
print(achievement)
# 获取字典全部key
achievement = {
    "zhangsan": 90,
    "lisi": 59,
    "wangwu": 85,
    "zhaoliu": 99
}
print(achievement.keys())
# 字典元素数量
print(len(achievement))

3、遍历

achievement = {
    "zhangsan": 90,
    "lisi": 59,
    "wangwu": 85,
    "zhaoliu": 99
}
for i in achievement.keys():
    print(i, achievement[i])
for i in achievement:
    print(i, achievement[i])

12、文件

12.1、文件对象获取

# 获取文件对象
file = open("./card.txt", "r", encoding="utf-8")
print(file)

12.2、文件读取

全力攻城！言退者，斩！
破曹大功，正在今朝！
吾主圣明，泽被臣属！
日夜攻打，必下此城！
可知我诸葛一氏，家学渊源？
传我将令，不得后退！
琅琊少年诸葛恪，金戈铁马立战勋！

1、read

# 获取文件对象
file = open("./card.txt", "r", encoding="utf-8")
# 读取文件内容
print(file.read())  # 设定读取长度，默认读取所有内容
# 关闭文件
file.close()

2、readlines

# 获取文件对象
file = open("./card.txt", "r", encoding="utf-8")
# 读取文件内容
print(file.readlines())  # 逐行读取文件，每一行作为一个列表项
# 关闭文件
file.close()

3、readline

# 获取文件对象
file = open("./card.txt", "r", encoding="utf-8")
# 读取文件内容
print(file.readline())  # 读取一行内容
print(file.readline())  # 读取一行内容
# 关闭文件
file.close()

4、优雅写法

with open("./card.txt", "r", encoding="utf-8") as file:
    print(file.read())

12.3、文件写入

1、覆盖写入

with open("./card.txt", "r", encoding="utf-8") as file:
    print(file.read())

# 写入文件
with open("./card.txt", "w", encoding="utf-8") as file:
    file.write("叔父，也不过如此吧！")
    file.flush()

with open("./card.txt", "r", encoding="utf-8") as file:
    print(file.read())

2、追加写入

with open("./card.txt", "r", encoding="utf-8") as file:
    print(file.read())

# 写入文件
with open("./card.txt", "a", encoding="utf-8") as file:
    file.write("\n全力攻城！言退者，斩！")
    file.flush()  # 真正写入文件中，close包含此功能

with open("./card.txt", "r", encoding="utf-8") as file:
    print(file.read())

13、异常

13.1、异常捕获

1、基本写法

try:
    file = open("card.md", "r", encoding="utf-8")
except:
    print("文件不存在")

try:
    file = open("card.md", "r", encoding="utf-8")
except Exception as e:
    print("文件不存在", e)

2、捕获指定异常

try:
    print(a)
except NameError as e:
    print("发生了变量为未定义异常", e)

try:
    1 / 0
except ZeroDivisionError as e:
    print("发生了除法异常", e)

3、捕获多个异常

try:
    1 / 0
except (ZeroDivisionError, NameError) as e:
    print("发生了除法异常", e)

13.2、else语句

未发生异常时会跳入else部分继续执行

try:
    print("hello world!")
except Exception as e:
    print("发生了异常", e)
else:
    print("未发生异常")

13.3、finally语句

无论发不发生异常都会执行

try:
    print("hello world!")
except Exception as e:
    print("发生了异常", e)
else:
    print("未发生异常")
finally:
    print("此处放置了异常监测点")

13.4、异常传递

def fun1():
    print(1 / 0)


def fun2():
    fun1()


def main():
    fun2()


if __name__ == '__main__':
    main()

def fun1():
    print(1 / 0)


def fun2():
    fun1()


def main():
    try:
        fun2()
    except Exception as e:
        print("发生了异常:", e)


if __name__ == '__main__':
    main()

14、模块

模块本质就是一个py文件，可以认为是一个工具包，以供复用

14.1、基础用法

1、import

import time

print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))
time.sleep(1)
print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))

import time as t

print(t.strftime("%Y-%m-%d %H:%M:%S",t.localtime()))
t.sleep(1)
print(t.strftime("%Y-%m-%d %H:%M:%S",t.localtime()))

2、from xx import xx

from time import sleep
from time import strftime
from time import localtime as mylocaltime

print(strftime("%Y-%m-%d %H:%M:%S", mylocaltime()))
sleep(1)
print(strftime("%Y-%m-%d %H:%M:%S", mylocaltime()))

14.2、自定义模块

1、基础用法

myModule.py

def myAdd(a, b):
    return a + b

test.py

import myModule

print(myModule.myAdd(1, 2))

2、同名覆盖

myModule.py

def myAdd(a, b):
    return a + b

myModule1.py

def myAdd(a, b):
    return a * b

test.py

from myModule import myAdd
from myModule1 import myAdd

print(myAdd(1, 2))

3、模块自动执行

myModule.py

def myAdd(a, b):
    return a + b


print(myAdd(2, 2))

test.py

from myModule import myAdd

print(myAdd(1, 2))

此时会发现模块里的函数调用也会执行，因为from的时候实际上是把模块里的内容执行了一遍

对module进行修改

def myAdd(a, b):
    return a + b


if __name__ == '__main__':
    print(myAdd(2, 2))

此时就不会发生上面的情况

if __name__ == '__main__'只有在运行这个模块的时候才会触发

4、_all_

用于限制全部导入时导出的方法/类等

myModule.py

__all__ = ["myAdd"]


def myAdd(a, b):
    return a + b


def myAdd1(a, b):
    return a + b + 1


if __name__ == '__main__':
    print(myAdd(2, 2))
    print(myAdd1(2, 2))

test.py

from myModule import *

print(myAdd1(1, 2))

14.3、常用模块

时间：time、datetime
随机数：random
os
sys
序列化：json、pickle
压缩：shutil
xml
configparser
hashlib
suprocess
日志：logging
正则：re

15、包

用于管理模块

python包下都有一个_init_.py文件

15.1、自定义包

new->python package

import xumeng.Add

print(xumeng.Add.Add(3, 4))

from xumeng.Add import Add

print(Add(3, 4))

15.2、_all_

写在_init_.py文件文件中用于控制import导入*时的模块

15.3、第三方包

pip镜像地址

阿里云：http://mirrors.aliyun.com/pypi/simple/

1、安装

pip install -i http://mirrors.aliyun.com/pypi/simple/ numpy

2、使用

如同自定义包使用方法

16、JSON

负责不同语言交互

16.1、转json

import json

a = [{"zhangsna": 123, "lisi": 231, "wangwu": 241},{"zhangsna": 123, "lisi": 231, "wangwu": 241}]
print(json.dumps(a))

16.2、解析json

import json

print(json.loads("[1, 2, 3, 4]"))

眼眸流转

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
1
评论
Python基础学习笔记

python基础语法学习
复制链接

扫一扫

专栏目录