【Python】学习笔记（一）：基础语法篇

1 基础知识

1.1 变量

1.1.1 数据类型

* 整形：int
* 浮点型：float
* 字符串：str
* 布尔型：bool
* 元组：tuple
* 集合：set
* 字典：dict

1.1.2 变量赋值

#变量名 = 值
num = 11
""" 解释 """
myName = "小灰灰"
print(myName)

1.1.3 标识符

1.2 格式化输出

myName = "小灰灰"
myAge = 18
myWeight = 49.9
myId = 9

print("姓名：%s" %myName)
print("年龄：%d" %myAge)
print("重量：%.2f" %myWeight) #两位小数.2f
print("学号：%06d" %myId) #学号：000009
print("姓名：%s, 年龄：%d" %(myName, myAge))

• %.2f 两位小数
• %06d 共6位，不足用0补全，超出原样输出

格式化字符串%s，还可以写为** f’{表达式}’**

myName = "小灰灰"
myAge = 18

print(f"姓名：{myName}, 明年年龄：{myAge + 1}")

• \n 换行
• \t 制表符，一个tab键
• end="\n" 结束符

print("my\tname")            #输出：my  name 再自动换行
print()                      #相当于 cout << endl;
print("my", end = "\t")      #修改结尾默认的换行符为（\t）或者（...）

1.3 输入和类型转换

• input输入的内容均为字符串

input("提示信息")
myName = input("请输入姓名：")
print(f"姓名是{myName}")

• 转换数据类型
  • int(x)
  • float(x)
  • str(x)
  • eval(str)
  • tuple(s) 将序列s转换成一个元组 t1 = (11, 22)
  • list(s) 将序列s转换成一个列表 list1 = [11, 22, 33]

num = input("数字：")
print(f"num的类型是{type(num)}")

intNum = int(num)
print(f"intNum的类型是{type(intNum)}")
str1 = "1"
print(type(eval(str1))) #自动转换

1.4 运算符

• 算数运算符
• 赋值运算符
• 复合赋值运算符
• 比较运算符
• 逻辑运算符

算数运算符

赋值运算符

复合赋值运算符

a = 10
a += 1 + 2 #先算1+2， 再计算10+3

比较运算符

逻辑运算符

print((2 > 1) and (3 > 4)) #返回True
print(not (1 > 2)) #返回True

拓展：数字之间的逻辑运算

1.5 常用函数

函数	解释
id(a)	a的地址
type(a)	a的类型

随机数

import random #导入随机模块
rNum = random.randint(0, 2) #0-2的随机整数

2 条件&循环语句

2.1 if 基本语法

num = int(input("请输入数字：")) #转换类型
if num > 5:
    print(f"输入的数字大于5,为{num}", end = "...haha...")
else :
    print(f"输入的数字小于5,为{num}", end = "...xixi...")

扩展 判断的化简

2.2 if 三元运算符

2.3 while 循环语法

注意更新计数器和退出条件

i = 0
while i < 5:
     i += 1
     print("666")

2.4 break和continue

使用continue之前，要更新循环计数器

2.5 for 循环语法

按字符，进行遍历

2.6 else的配合使用

2.6.1 while…else

2.6.2 for…else

3 字符串

• 下标、切片、常用操作

3.1 书写方法

# 单引号 'xhh'
# 双引号 "xhh"
# 三引号 """ xhh """ ->可以输出换行操作~
str = """ my
name is 
xhh"""
str2 = 'I\'m TOM' # \' 转义字符

3.2 下标

str = "abc" # str[0]  得到a ；  str[2]  得到r

3.3 切片

str = "abcde"
str[0:2:1] # ab 含左不含右
str[::-1]  # 表示倒序
str[-5:-1] # -1表示最后一个

3.4 字符串常用函数

3.4.1 查找find() & index()

字串，不是字符，返回为索引值

• find() 查不到返回-1
• index() 查不到，程序错误

其他 str.xxx()

• .count() 计数
• .rfind() 右侧开始
• .rindex() 右侧开始

3.4.2 修改replace() & split() & join()

str3 = "a b c a"
s = str3.replace("a", "6666")

注意是分割字符

str = "a and b and c"
list = str.split("and", 1) # ['a ', ' b and c']

list = ["aa", "bb", "cc"]
newStr = "...".join(list) # aa...bb...cc

3.4.3 大小写转换

* capitalize()  第一个首字母大写
* title()  每个单词首字母大写
* lower() 转小写
* upper() 转大写

changeStr = str.capitalize()

3.4.4 删除空白、对齐

* **ljust() 左对齐**
* **rjust() 右对齐**
* **center() 居中**

str = "hello"
str.ljust(10) # 左对齐 
str.ljust(10, ".") # 左对齐 .填充

3.4.5 判断

* **startswith()**
* **endswith()**

* **isalpha()   至少有一个字符，且全部字符都为字母返回True**
* **isdigit() 只包含数字，返回True**
* **isplace() 只包含空白，返回True**

4 列表&元组&字典&集合

4.1 列表 [ ]

4.1.1 下标

nameLise = ["xhh", "zph"]
print(nameLise[0]) # xhh

4.1.2 函数

函数与字符串操作方法一样

• index()
• count()
• len() # 公共函数

4.1.3 判断是否存在

4.1.4 增加

• append() 列表结尾追加数据
• extend() 列表结尾->追加列表(每个列表元素放进去)，->若为"abc"，则每个字符添加
• insert() 指定位置新增数据

nameList = ["xhh", "zph"]
addList = ["aa", "bb"]

nameList.append(addList)     # ['xhh', 'zph', ['aa', 'bb']]
nameList.extend(addList)     # ['xhh', 'zph', 'aa', 'bb']
nameList.insert(0, addList)  # [['aa', 'bb'], 'xhh', 'zph']

4.1.5 删除

• del() 删除目标
• pop() 删除下标
• remove() 删除数据
• clear() 清空列表

nameList = ["xhh", "zph"]

# 1.del()
del nameList # 删除列表 or del (nameList)
del nameList[0] # 删除 "xhh"

# 2.pop() 默认删除最后一个值，返回被删除的数据
nameList.pop()  # 默认删除最后一个数据
nameList.pop(0) # 删除"xhh"

# 3.remove()
nameList.remove("xhh") # 删除"xhh"

# 4.clear()
nameList.clear() # 结果[]

4.1.6 修改

• nameList[0] 修改指定下标数据
• reverse() 逆置
• sort() 排序

nameList = ["xhh", "zph"]

# 1.指定下标修改
nameList[0] = "xhhChange"

# 2.reverse() 逆置
nameList.reverse()

# 3.sort(key = None, reverse = False) 排序 字典中的Key，reverse默认升序
nameList.sort()               # 升序
nameList.sort(reverse = True) # 降序

4.1.7 复制

数据很重要

• copy()

nameList = ["xhh", "zph"]
copyList = nameList.copy()

4.1.8 列表的循环遍历

【while循环】

nameList = ["xhh", "TOM", "zph"]

i = 0
while i < len(nameList):
    print(nameList[i])
    i += 1 # 更新循环因子

【for循环】

nameList = ["xhh", "TOM", "zph"]

for str in nameList:
    print(str)

4.1.9 列表嵌套

nameList = [["小明", "小红"], ["TOM", "XHH"]]

nameList[0]     # ["小明", "小红"]
nameList[0][0]  # 小明

4.2 元组 ( )

**存储多个数据&&**不能修改数据

tuple_1 = (11, 22, 33) # 多个数据
tuple_2 = (11, )       # 单个数据

元组的常见操作(仅支持查找)

• 下标查数据 tuple_1[0]
• index()
• count()
• len()

特殊：元组中的列表可以修改

tuple_1 = ("xhh", "zph", ["11", "22"])

# 元组中的列表[]是可以修改的
tuple_1[2][0] = "10"

4.3 字典 { }

4.3.1 字典的语法

dict_1 = {"name": "XHH", "age": "18"}
dict_2 = dict()
dict_3 = {}

4.3.2 增加&修改

* **dict[key] = value**

如果key存在，则修改key；如果key不存在，则新增key

dict_1 = {"name": "XHH", "age": "18"}

# 1.修改
dict_1["name"] = "zph"

# 2.新增
dict_1["class"] = "研究生"

4.3.3 删除

* del() / del   删除字典或删除字典中指定的键值对
* clear()  清空字典

dict_1 = {"name": "XHH", "age": "18"}

del dict_1         # 删除 or del(dict_1)
del dict_1["name"] # 删除键值对
dict_1.clear()     # 清空数据

4.3.4 查找

* key值查找
* get(key, 默认值)
* keys()
* values()
* items()

dict_1 = {"name": "XHH", "age": "18"}


# 1.[key] 键值对
print(dict_1["name"]) # XHH

# 2 函数
# 2.1 get(key, 默认值)
print(dict_1.get("name"))
print(dict_1.get("names")) # 不存在，返回默认None
print(dict_1.get("names", "999")) # 不存在，返回修改默认999

# 2.2 keys() 查找字典中的所有key，返回可迭代的对象
print(dict_1.keys()) # ['name', 'age']

# 2.3 values() 查找字典中的所有value，返回可迭代的对象
print(dict_1.values()) # ['XHH', '18']

# 2.4 items() 查找字典中所有的键值对，返回可迭代的对象，里面的数据是元组
print(dict_1.items()) # [('name', 'XHH'), ('age', '18')]

4.3.5 字典的遍历

* 遍历key
* 遍历value
* 遍历字典的元素（键值对）
* 遍历字典的键值对（拆包）

dict_1 = {"name": "XHH", "age": "18"}

# 1.遍历key
for key in dict_1.keys():
    print(key)
    
# 2.遍历value
for value in dict_1.values():
    print(value)

# 3.遍历元素
for item in dict_1.items():
    print(item)
    
# 4.遍历字典的键值对（拆包）
for key, value in dict_1.items():
    print(f"{key} = {value}")

4.4 集合 { }

创建集合使用{}或set()
⭐创建空集合只能用set()
⭐****集合去重

s1 = {11, 22}
s2 = set()
s3 = set("abc") # {'a', 'c', 'b'}

4.4.1 增加

* **add()         *****只能 *****增加单一数据**
* **update()   *****只能 *****增加序列数据**

s1 = {11, 22}

# add() 可以增加在任意位置
s1.add(100)

# update()
s1.update([22, 33, 44])

4.4.2 删除

* **remove()   删除指定数据，不存在报错**
* **discard()   删除指定数据，不存在不会报错**
* **pop()   随机删除某个数据，****并返回这个值**

s1 = {11, 22, 33}

s1.remove(11)
s1.discard(11)
s1.pop()

4.4.3 查找

返回**True **和 False

• in 判断数据在集合序列里面
• not in 判断不在里面

s1 = {11, 22, 33}
print(11 in s1)

5 公共操作

5.1 运算符

5.2 公共方法

enumerate(可遍历对象， start = 0)

list_1 = [11, 33, 22]

maxNum = max(list_1)
minNum = min(list_1)

# 获取一组数据
for i in range(1, 10, 1):
    print(i) # 1 2 3 ... 9 不包含10
for i in range(10):
    print(i, end = " ") # 0 1 ... 9 不包含10
for i in enumerate(list_1):
    print(i, end = " ") # (0, 11) (1, 33) (2, 22)

for i in enumerate(list_1, start = 1):
    print(i, end = " ") # (1, 11) (2, 33) (3, 22) 下标从1开始

5.3 容器数据类型的转换

* **list()  转换成列表   --  list(tuple_1)**
* **tuple()  转换成元组**
* **set()  转换成集合**

5.4 推导式

简化代码

• 列表[ ]推导式
• 字典{ }推导式
• 集合{ }推导式

5.4.1 列表推导式

用一个表达式创建一个有规律的列表或控制一个有规律列表

【需求创建0 - 9 的列表】

for推导式实现

# 1.while实现
list1 = []
i = 0
while i < 10:
    list1.append(i)
    i += 1
    
# 2.for实现
list2 = []
for i in range(10):
    list2.append(i)
    
# 3.推导式实现
list3 = [i for i in range(10)]

【创建】

if推导式实现

# 1.for
list2 = [i for i in range(0, 10, 2)]

# 2.for - if
list3 = [i for i in range(10) if i % 2 == 0]

多个for循环实现列表推导式

# 需要生成 [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
list4 = [(i, j) for i in range(1, 3) for j in range(3)]

5.4.2 字典推导式

快速合并列表为字典或提取字典中目标数据

【1. key：1-5， value：这个数字的平方】

dict1 = {i: i**2 for i in range(5)}

【2. 将两个列表合并为一个字典】

list1 = ["name", "age", "gender"]

list2 = [“Tom”, 18, “man”]

dict2 = {list1[i]: list2[i] for i in range(len(list1))}

【3. 提取字典中的目标数据】

counts = {"MBP": 268, "HP": 201, "Lenovo": 199}

# 提取数量 > 200 的字典数据
count1 = {key: value for key, value in counts.items() if value >= 200}
print(count1)

5.4.3 集合推导式

集合：去除功能

set1  = {i ** 2 for i in range(3)} # {0, 1, 4}

6 函数&拆包和交换变量的值

6.1 函数的使用步骤

必须先定义后调用

• 定义函数
• 调用函数

# 定义函数
def 函数名(参数):
    代码...
    
# 函数调用
函数名(参数)

6.2 函数参数&返回值

# 1.定义函数 a，b 形参
def addNum2(a, b):
    """ 函数的说明文档：求和函数 """
r      return a + b # 退出当前函数，后面的代码不执行
  
# 2.调用函数 11，22 实参
print(addNum2(11, 22))
help(addNum2) # 查看函数的说明信息

多个返回值 默认：返回元组

def returnNums():
    return 11, 22
    #return后可以直接书写 元组/列表/字典  默认：元组
print(returnNums()) # (11, 22)

6.3 全局变量&局部变量

a = 100 # 定义全局变量
def test1():
    print(a)         # 全局变量
    
def test2():
    a = 200  #局部变量
    print(a) #局部变量 
    
# 若要修改全局变量a
def test3():
    global a = 22    # 全局变量
    print(a)

6.4 函数的参数

6.4.1 位置参数

def userInfo(name, age, gender):
    print(f"姓名:{name}, 年龄：{age}, 性别：{gender}")
    
# 传入参数要对应位置和数量
userInfo("Xhh", 18, "男")

6.4.2 关键字参数

**通过 key = value 可以无序 && **位置参数必须在关键字参数前面

userInfo(name= "xhh", gender= "男", age= 19)

6.4.3 缺省参数（默认参数）

缺省参数必须放在末尾

def userInfo(name, age, gender = "男"):
    print(f"姓名:{name}, 年龄：{age}, 性别：{gender}")

6.4.4 不定长参数（可变参数）

可以修改 *name **kwname

• args 包裹位置传递 ** 返回元组( )*
• **kwargs 包裹关键字传递 返回字典{ }

# 1.包括位置传递
def userInfo(*args):
    print(args)
    
userInfo("Xhh", 18) # ('Xhh', 18) 返回元组
# 2.包裹关键字传递
def userInfo(**kwargs):
    print(kwargs)
    
userInfo(name = "Xhh", age = 18) # {'name': 'Xhh', 'age': 18}

6.5 拆包

元组的拆包

def returnNum():
    return 11, 22  # 返回了(11, 22)

num1, num2 = returnNum() # 拆包-> num1 = 11, num2 = 22

字典的拆包

dict1 = {'name': 'Xhh', 'age': 18}
a, b = dict1

# 字典拆包，取出对应的key
print(a) # name
print(b) # age

# 字典根据key，取出value
print(dict1[a]) # Xhh
print(dict1[b]) # 18

6.6 交换变量的值

【方法一：借助临时变量c】

a, b = 11, 22
c = a
a = b
b = c

【方法二：化简写法】

a, b = 11, 22

a, b = b, a  # 交换

6.7 引用

python中，值是靠引用来传递的 **id( ) **可以判断地址
引用当作实参

def test1(a):
    print(a)
    print(id(a))
    
    a += a
    print(a)
    print(id(a))
    
# 引用做实参传递
b = 100
test(b)  # 可以的 100, 200 两次id不同，分别指向不变int类型的100 和 200
# 第二种数据类型
c = [11, 22]
test(c)  #可以输出[11, 22]、[11, 22, 11, 22],两次id一样，指向可变类型list

• 可变类型
  • 列表
  • 字典
  • 集合
• 不可变类型
  • 整形
  • 浮点型
  • 字符型
  • 元组

6.8 递归

快速遍历文件，人工智能算法

• 函数内部自己调用自己
• 必须有出口

递归 计算3 + 2 + 1

def sumNums(num):
    # 1.如果是1,直接返回1  --  出口
    if num == 1:
        return 1
    # 2.如果不是1,重复执行累加并返回结果
    return num + sumNums(num - 1)


print(sumNums(3))

7 lambda 匿名函数 & 高阶函数

7.1 lambda语法

如果函数有一个返回值，并且只有一句代码，可以使用lambda简化

 lambda 参数列表： 表达式

• 参数列表可有可无
• 可以接受任意数量的参数但只能返回一个值

【示例：返回值】

# 需求：返回值100

# 1.函数
def func1():
    return 100

# 2.lambda 匿名函数
func2 = lambda: 100
func2() # 函数调用，这个就是返回值

【示例：a+b】

# 1.函数
def addNums(a, b):
    return a + b

result = addNums(11, 22)

# 2.匿名函数
func = lambda a, b: a + b

result = func(11, 22)

7.2 lambda的参数形式

# 1.无参数
func = lambda: 100

# 2.一个参数
func = lambda a: a
print(func("XHH"))

# 3.默认参数
func = lambda a, b = 22: a + b
print(func(11))

# 4.可变参数*args  返回元组
func = lambda *args: args
print(func(11, 22))

# 5.可变参数**kwargs  返回字典
func = lambda **kwargs: kwargs
print(func(name = 'python', age = 18))

7.3 lambda的应用

7.3.1 带判断的lambda

func = lambda a, b: a if a > b else b
print(func(11, 22))

7.3.2 列表数据按字典key的值排序

students = [
    {'name': 'Xhh', 'age': 11}, 
    {'name': 'zph', 'age': 33},
    {'name': 'Link', 'age': 22}
    ]

# 按照年龄降序排列
students.sort(key = lambda x: x['age'], reverse = True)

7.4 高阶函数

把函数作为参数传入，化简代码，增加代码的灵活性

7.4.1 函数作参数

• abs( ) 求绝对值
• round( ) 对数字进行四舍五入

【示例】

def sumNums(a, b, func):
    return func(a) + func(b)

result = sumNums(-1, 22, abs) # 函数abs作为参数传进去
print(result) # 23

7.4.2 内置高阶函数

map(func, list) ，将函数作用与列表的每个元素，并返回迭代器

# 计算各个数组的二次方
list1 = [3, 4, 5]

def func(x):
    return x ** 2

result = map(func, list1) # 返回迭代器
print(result) # 

reduce(func, list)， 其中func必须有两个参数。
每次func计算的结果和序列的下一个元素做累计计算
注意：reduce() 传入的参数 func必须接受两个值
import functools

# 计算list1序列中各个数字的累加和
import functools

list1 = [3, 4, 5]

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

result = functools.reduce(func, list1)
print(result)

filter(func， list) 用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象
如果要转化为列表，可以使用list( )来转换

list1 = [3, 4, 5]

# 定义条件
def func(x):
    return x % 2 == 0

result = filter(func, list1)
print(result)         # 
print(list(result))   # [4]

8 文件操作

8.1 文件操作步骤

• 打开文件
• 读写操作
• 关闭文件

8.2 打开文件

open(name, mode) # 文件名or地址    打开模式 
f = open('test.cpp', 'w') # 创建文件对象

8.2.1 写入文件

对象.write('内容')

8.2.2 读取文件

• read( )

对象.read(num) # num读取字节数

• readlines( )

对象.readlines()
con = f.readlines()
print(con) # ['aaa\n, 'bbb\n', 'ccc'], 

• readline( )

cont = f.readline()
print(f'第一行内容：{cont}')
cont = f.readline()
print(f'第二行内容：{cont}')

8.2.3 文件操作示例

# 1.打开 open()
f = open('test.txt', 'w')

# 2.读写操作 write() read()
f.write('xhh')

# 3.关闭 close()
f.close()

8.3 访问模式

8.4 seek( )

改变文件指针位置

对象.seek(偏移量, 起始位置)

* 起始位置
* 0：文件开头
* 1：当前位置
* 2：文件结尾

8.5 [示例]文件的备份

需求：用户输入当前目录下任意文件名，完成备份（备份文件名为xx[备份]后缀）

oldName = input("请输入您要备份的文件名：")
print(oldName)

index = oldName.rfind('.')
# print(index)

newName = oldName[:index] + '[备份]' + oldName[index:]


oldF = open(oldName, 'rb')
newF = open(newName, 'wb')

# 不确定目标大小，循环读取
while True:
    con = oldF.read(1024)
    if len(con) == 0:
        break
    
    newF.write(con)
    
oldF.close()
newF.close()

8.6 文件和文件夹的操作

import os # 导入模块

8.6.1 文件or文件夹的重命名

os.rename(原文件名, 新文件名)
os.rename('xhh.py', 'xhhNew.py')

8.6.2 删除文件

os.remove(文件名)

8.6.3 创建文件夹

os.mkdir('文件夹')

8.6.4 删除文件夹

os.rmdir('文件夹')

8.6.5 获取当前目录

os.getcwd() # 返回当前文件的路径

8.6.6 改变默认目录

os.chdir('目录')

8.6.7 获取目录列表

os.listdir() # 当前目录的文件名，返回为列表[  ]

8.6.8 文件夹的重命名

os.rename('777', 'new777')

8.7 [示例]批量修改文件名

import os

fileList = os.listdir()

print(fileList)

for i in fileList:
    newName = 'Python' + i
    
    os.rename(i, newName)

9 二级Python plus

9.1 format、round、end

9.2 基本数据结构

1 进制

2 字符串类型转换

3 字符串操作

4 集合

5 序列

a = '  vbn  '
a.strip(" ") # 'vbn'  删除功能
b = "a,b,c"
b.split(",") # ["a", "b", "c"]  切片

9.3 内置函数

9.4 第三方库

import turtle
from random import *
 

1 turtle

turtle.circle(50, 90)       # 90度圆
turtle.circle(50, steps= 3) # 变长50的3角形

2 random

3 time

4 PyInstaller

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8c9vRsD6-1582964728920)(https://uploader.shimo.im/f/KTivFeFAnm8lcTz2.png!thumbnail)]

5 jieba & wordcloud

from wordcloud import WordCloud

from wordcloud import WordCloud

txt = "i like Python, Python is good"

word = WordCloud().generate(txt) # 存储为词云
word.to_file("1.png")            # 显示为图片

6 其他