【深度学习入门】深度学习四板斧其一 -- Python入门学习笔记1

茗小丧帅

已于 2023-06-29 16:18:13 修改

阅读量173

点赞数

文章标签： python 深度学习

于 2023-06-24 23:03:50 首次发布

本文链接：https://blog.csdn.net/qq_45891093/article/details/131367830

版权

python学习视频地址：点击跳转

一、基础语法

-字面量：
代码中，被写下来的固定的值，常用的有6种。
数字（Number）：整数（int）、浮点数（float）、复数（complex）、布尔（bool）
字符串（String）
列表（List）：有序的可变序列
元组（Tuple）：有序的不可变序列
集合（Set）：无序不重复集合
字典（Dictionary）：无序Key-Value集合
-注释：

# 单行注释

"""
多行注释
"""

-变量与数据类型：
使用type()可查看数据的类型。

name = "你好"
name_type = type(name)

在Python中，变量没有类型！而变量中存储的数据有类型。
-数据类型转换：
int(x)：将x转换为一个整数
float(x)：将x转换为一个浮点数
str(x)：将x转换为字符串
-标识符：
对变量、类、方法等编写的名字。
需遵守规则：内容限定（英文、数字、下划线、中文）、大小写敏感、不可使用关键字
-运算符：
±*/ 加减乘除
//：整除
%：取余
**：求平方
-字符串：
字符串有三种定义方式：‘字符串’、“字符串”、“”“字符串”“”
字符串之间可以使用 + 来进行拼接，其他类型需要格式化后再拼接。
字符串格式化使用占位符进行操作，常用的占位符有%s、%d、%f。
字符串格式化可以进行精度控制，如%5d、%5.2f、%.2f 。
字符串也可以进行快速格式化，通过 f"{变量}{变量}" 的方式。

apple = 3
banana = 5
price = "苹果的价格是%s元，香蕉的价格是%s元" % (apple, banana)
print(price)
print(f"苹果的价格是{apple}元，香蕉的价格是{banana}元")

-数据输入：

name = input("请输入你要购买的水果")
print("谢谢购买：%s" % name)

二、基础语句

-if语句：

print("现在水果正在搞活动")
if int(input("请输入您的身高（cm）:")) < 120:
    print("小朋友可以免费领取一份水果。")
elif int(input("请输入您的VIP等级:")) > 3:
    print("高级会员可以免费领取一份水果。")
elif int(input("请输入今日日期:")) == 1:
    print("每月一号可以免费领取一份水果。")
else:
    print("可享受五折优惠购买一份水果。")

-while语句：

#九九乘法表
i = 1
while i <= 9:
    j = 1
    while j <= i:
        # end=''实现不换行，\t 为制表符
        print(f"{j} * {i}= {j * i}\t",end = '')
        j += 1
    i += 1
    print()

-for语句：
注意：Python中for的使用与C语言不同，需要区分。

#range:获取一个数字序列
#0 1 2 3 4 5 6 7 8 9
for x in range(10):
    print(x , end=' ')
#5 6 7 8 9
for x in range(5,10):
    print(x , end=' ')
#5 7 9
for x in range(5,10,2):
    print(x , end=' ')

#九九乘法表
for i in range(1,10):
    for j in range(1,i + 1):
        print(f"{j} * {i} = {j * i}\t",end='')
    print()

-continue和break语句：
continue：中断所在循环的当次执行，直接进入下一次
break：直接结束所在的循环

三、函数

-函数的定义：
global关键字，可设置局部变量为全局变量。

def add(x,y):
    return x + y
print(f"2 + 3 = {add(2,3)}")

-函数的多个返回值：

def double_return():
    return 1,2
x,y = double_return()
print(f"{x},{y}")
#输出： 1,2

-函数的多种参数使用方式：

def my_info(name,age,gender):
    print(f"姓名是：{name}，年龄是：{age}，性别是：{gender}")
#位置参数
my_info('张三',24,'男')

#关键字参数
my_info(age=10,name='李小四',gender='男')

#缺省参数（默认值）
def my_info1(name,age,gender='保密'):
    print(f"姓名是：{name}，年龄是：{age}，性别是：{gender}")
my_info1('林克',13)

#不定长 - 位置不定长 *号
def user_info(*args):
    print(args)
user_info(1,2,3)
#输出：(1, 2, 3)

#不定长 - 关键字不定长 **号
def user_info(**kwargs):
    print(kwargs)
user_info(apple=1,banana=2,peach=3)
#输出：{'apple': 1, 'banana': 2, 'peach': 3}

-函数作为参数传递：

def test_func(compute):
    result = compute(1,2)
    print(f"{type(compute)},{result}")
def compute(x,y):
    return x + y
test_func(compute)
#输出：<class 'function'>,3

-lambda匿名函数：
lambda关键字定义匿名函数，只可临时使用一次。

def test_func(compute):
    result = compute(1,2)
    print(result)
test_func(lambda x , y : x + y)
#输出：3

四、数据容器

-list列表：#与C语言中的数组相似
列表内的每一个数据，称之为元素，列表定义为[元素1，元素2，元素3，…]
元素的数据类型没有任何限制，甚至元素可以是列表，即可定义嵌套列表。

my_list = [[1,2,3],[4,5,6]]
print(my_list)
print(type(my_list))
print(my_list[0][0])
print(my_list[1][2])
print(my_list[-1][-1])

程序输出：
[[1, 2, 3], [4, 5, 6]]
<class ‘list’>
1
6
6
-list列表的方法：

#append 向列表追加一个元素
my_list.append(4)
#extend 在列表尾部追加一个容器
my_list.extend([5,6,7])
#在指定下标处，插入指定的元素
my_list.insert(7,8)
#删除列表指定下标元素
del my_list[7]
#删除列表指定下标元素
my_list.pop(6)
#从前向后，删除此元素第一个匹配项
my_list.remove(6)
#清空列表
my_list.clear()
#统计此元素在列表中出现的次数
my_list.count(1)
#查找指定元素在列表的下标 找不到报错Value
my_list.index(1)
#统计容器内有多少元素
len(my_list)

-list列表的遍历：

my_list = [1,2,3,4,5]
index = 0
while index < len(my_list):
    element = my_list[index]
    print(f"列表的元素有：{element}")
    index += 1

my_list = [1,2,3,4,5]
for element in my_list:
    print(f"列表的元素有：{element}")

-tuple元组：#可以理解为只读的list列表
元组内的每一个数据，称之为元素，元组定义为（元素1，元素2，元素3，…）
如果元组内嵌套了一个列表，则列表可以修改。

t1 = ((1,2,3),(4,5,6))
print(f"t1的类型是{type(t1)},t1的内容是{t1}")
index = t1.index((4,5,6))
print(index)
count = t1.count(1)
print(count)
count = t1.count((1,2,3))
print(count)
len = len(t1)
print(len)

程序输出：
t1的类型是<class ‘tuple’>,t1的内容是((1, 2, 3), (4, 5, 6))
1
0
1
2
-str字符串：#不可修改的只存放字符的list列表

my_str = "apple and banana"
#index 查找某字符的下标
print(my_str.index("and"))
#程序输出: 6

#replace 替换字符串中的字符串1 为 字符串2
new_my_str = my_str.replace("and","or")
print(new_my_str)
#程序输出: apple or banana

#split 切分字符串为列表
my_list = my_str.split(" ")
print(my_list)
#程序输出: ['apple', 'and', 'banana']

#strip 规整字符串
my_str = "  apple and banana  "
print(my_str.strip())
my_str = "12apple and banana21"
print(my_str.strip("12"))
#程序输出:
#apple and banana
#apple and banana

#统计字符串中某字符的出现次数
print(my_str.count("apple"))
#程序输出:1

#统计字符串的长度
print(len(my_str))
#程序输出:20

-序列：#列表、元组、字符串，均可视为序列
内容连续、有序，支持下标索引的一类数据容器，称之为序列。
序列的切片操作：从一个序列中，取出一个子序列
序列的切片操作的语法：序列[起始下标：结束下标：步长]
步长为负数时，表示反向取，此时下标也要反向标。
-set集合：#无序且元素不重复
定义：{元素1，元素2，元素3，…}
空集合使用 set{} 来进行定义。

my_set = {"apple","banana","peach"}
#添加新元素
my_set.add("nop")
print(my_set)
#输出：{'peach', 'nop', 'apple', 'banana'}

#移除元素
my_set.remove("nop")
print(my_set)
#输出：{'banana', 'peach', 'apple'}

#随机取出一个元素
print(my_set.pop())
print(my_set)
#输出：
# peach
# {'apple', 'banana'}

#清空集合
my_set.clear()
print(my_set)
#输出：set()

#取两个集合的差集
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.difference(set2)
print(set1)
print(set2)
print(set3)
#输出：
# {1, 2, 3}
# {1, 5, 6}
# {2, 3}

#清除两个集合的差集
set1 = {1,2,3}
set2 = {1,5,6}
set1.difference_update(set2)
print(set1)
print(set2)
#输出：
# {2, 3}
# {1, 5, 6}

#两个集合合并为一个
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
print(set1)
print(set2)
print(set3)
#输出：
# {1, 2, 3}
# {1, 5, 6}
# {1, 2, 3, 5, 6}

#统计集合元素数量
print(len(set1))
#输出：3

#集合的遍历,不能使用while
set1 = {1,2,3}
for x in set1:
    print(x,end = ' ')
#输出：1 2 3

-dict字典：#无序且不重复
定义：{ key:value , key:value , key:value ,…}
空字典可以用 {} 或 dict{} 来进行定义。

my_dict = {"apple":3,"banana":5,"peach":6}
#新增元素
my_dict["watermelon"] = 2
print(my_dict)
#输出：{'apple': 3, 'banana': 5, 'peach': 6, 'watermelon': 2}

#更新元素
my_dict["watermelon"] = 1
print(my_dict)
#输出：{'apple': 3, 'banana': 5, 'peach': 6, 'watermelon': 1}

#删除元素
print(my_dict.pop("watermelon"))
print(my_dict)
#输出：
# 1
# {'apple': 3, 'banana': 5, 'peach': 6}

#清空元素
my_dict.clear()
print(my_dict)
#输出：{}

#获取全部的key
my_dict = {"apple":3,"banana":5,"peach":6}
keys = my_dict.keys()
print(keys)
#输出：dict_keys(['apple', 'banana', 'peach'])

#遍历字典
#方式1 获取字典的全部key来进行遍历
for key in keys:
    print(key,end = ' ')
    print(my_dict[key],end = ' ')
#方式2 直接对字典进行for循环
for key in my_dict:
    print(key,end = ' ')
    print(my_dict[key],end = ' ')
#输出：apple 3 banana 5 peach 6

#统计字典的元素数量
print(len(my_dict))
#输出：3

-数据容器特点对比：
列表：一批数据，可修改、可重复的存储场景
元组：一批数据，不可修改、可重复的存储场景
字符串：一串字符串的存储场景
集合：一批数据，去重存储场景
字典：一批数据，可用于Key检索Value的存储场景
-数据容器的通用操作：
均可使用for进行循环遍历，
求元素个数len()、求最大元素max()、求最小元素min()、
转列表list()、转字符串str()、转元组tuple()、转集合set()、
排序sorted(容器，reverse = True)，True为升序，False为降序，
注意排序后容器均将转化为列表。

五、文件操作

-文件的读取操作：

#打开文件
f = open("test.txt","r",encoding="UTF-8")
print(type(f))
#输出：<class '_io.TextIOWrapper'>

#读取文件 - read()
print(f.read(10))
#输出：day day a

#读取文件 - readLines() -读取文件全部行，封装在列表中
#读取文件 - readLine() -读取文件的一行
print(f.readlines())
#输出：['apple\n', 'doctor doctor scare me']

#for 循环读取文件行
for line in f:
    print(line)

#文件的关闭
f.close()

#with open 语法操作文件 - 会自动关闭文件
with open("test.txt","r",encoding="UTF-8") as f:
    for line in f:
        print(line)

-文件的写入操作：

#打开文件
f = open("test.txt","w",encoding="UTF-8")
#文件写入 - 内容暂存在内存中
f.write("apple apple apple!")
#内容刷新 - 内容写入到文件中
f.flush()
#关闭文件 - close内置了flush的功能
f.close()
#打开文件 - 追加写入
f = open("test.txt","a",encoding="UTF-8")

六、异常

-捕获异常：

#基本捕获语法
try:
    f = open("test.txt", "r", encoding="UTF-8")
except:
    f = open("test.txt", "w", encoding="UTF-8")

#捕获指定异常
try:
    print(name)
except NameError as e:
    print(e)
#输出：name 'name' is not defined

#捕获多个异常
try:
    print(name)
except (NameError,ZeroDivisionError) as e:
    print(e)

#捕获全部异常
try:
    print(name)
except Exception as e:
    print(e)
else:
    print("正常输出")
finally:
    print("无论是否出现异常，均将执行")

-异常的传递性：
如果一段代码调用了一个函数，函数内出现异常但没有捕获，则可在代码段进行捕获，称之为异常的传递性，如果都没有捕获到异常，程序就会报错。
-模块及其导入：
模块即一个Python文件，以.py结尾，里面有类、函数、变量等，可以直接拿来用。

#导入time模块
import time

#使用导入模块的sleep功能
time.sleep(1)

#使用from导入模块的sleep功能
from time import sleep
sleep(1)

#使用*导入time模块的全部功能
from time import *
sleep(1)

#使用as给特定功能加上别名
import time as t
t.sleep(1)
from time import sleep as sl
sl(1)

-自定义模块：
当导入多个模块时，且模块有同名功能，调用该功能时，调用的是后面导入的模块的功能。
main的作用：只有当程序是直接执行时才进入if内部，如果是被导入的，则无法进入if。
all的作用：可以控制import *的时候哪些功能可以被导入。

if __name__ == '__main__':
    test()
#只导入test
__all__ = ['test']
from module import *

-Python包：
物理上看，包就是一个文件夹，该文件夹包含了一个init.py文件，该文件可用于包含多个模块文件；从逻辑上看，包的本质还是模块。

#方法1
import my_package.module1
import my_package.module2
my_package.module1.print1()
my_package.module2.print2()
#方法2
from my_package import module1
from my_package import module2
module1.print1()
module2.print2()
#方法3
from my_package.module1 import print1
from my_package.module2 import print2
print1()
print2()