Python学习笔记

python 基础语法

一、字面量

在 python 中，有 6 种常见的数据类型：

类型	描述	说明
数字(Number)	整数(int)、浮点数(float)、复数(complex)、布尔(bool)	复数(complex)：如4+3j，以j结尾表示复数
字符串(String)	-	-
列表(List)	有序的可变序列	Py 中使用最频繁的数据类型，可有序记录一堆数据
元组(Tuple)	有序的不可变序列	可有序记录一堆不可变的 py 数据集合
集合(Set)	无序不重复集合	可无序记录一堆不可变的 py 数据集合
字典(Dictionary)	无序 key-value 集合	可无序记录一堆 key- value 型的 py 数据集合

二、转换函数

• int(x)：将 x 转换为一个整数
• float(x)：将 x 转换为一个浮点数
• str(x)：将对象 x 转换为字符串
  
  

三、python 命令规则

在 python 的命名规则中，大小写敏感，标识符命名中，只允许出现：

• 英文
• 中文（不推荐使用）
• 数字（不可用作开头）
• 下划线（_）

除了这四类元素，其他任何内容都不被允许。关键字也不被允许使用，关键字如下：

四、python 运算规则

除了常见的 +，-，*，/；还有

• //： 取整数（10 // 3 = 3）
• %：取余（10 % 3 = 1）
• **：指数（2 ** 3 = 8）

五、字符串格式化

• %s：其中 % 表示我要占位，s 表示将变量变成字符串放入占位的地方。
  举例：

  name = "abc"
  message = "cde%s" % name
  print(message) # cdeabc
  

  class_num = 50 # 班级人数
  avg_score = 80
  print("该班级总共有：%s人，平均分数为：%s" % (class_num, avg_score)) # 该班级总共有：50人，平均分数为：80
  

在 python 中，最常用的是如下三类占位符：

• %s：将内容转换成字符串，放入占位位置。
• %d：将内容转换成整数，放入占位位置。
• %f：将内容转换成浮点数，放入占位位置。

六、数据输入 input

name = input()
print("我知道了，你是：%s" % name)

七、py 中 if 的使用

age = 88if age >= 18:print("我已经成年了")
print("时间过的真快呀")

age = 8if age >= 18:print("我已经成年了")
else:print("你还未成年")

age = 8if age >= 18:print("我已经成年了")
elif height > 180:print("你只是长的像大人")
else:print("你还未成年")

八、随机函数

import random
num = random.randint(1, 10)guess_num = int(input("输入你要猜测的数字："))if guess_num == num:print("恭喜，第一次就猜中了")
else:if guess_num > num:print("你猜测的数字大了")else:print("你猜测的数字小了")

九、while 循环的基础应用

i = 0
while i < 10:print("循环了")i += 1

十、while 循环九九乘法表

i = 1
while i <= 9:j = 1while j <= i:print(f"{j} * {i} = {j * i}\t", end="")j += 1i += 1print()

十一、for 循环

• range 语法1 range(num)
• range 语法2 range(num1, num2)
• range 语法3 range(num1, num2, step)：step 为步长

for x in range(5, 10):print(x)

十二、嵌套 for 循环

for i in range(1, 101):print(f"今天是第{i}天")for j in range(1, 11):print(f"今天的第{j}次循环")

十三、嵌套 for 循环打印九九乘法表

for i in range (1,10):for j in range (1,10):print(i,"X",j,"=",i*j,"\t",end="")#end=""表示不换行if i == j:print("")break

十四、自定义函数

• 无返回值：

  def fun(str):count = 0for i in str:count += 1print(f"字符串{str}的长度为:", count)
  

• 有返回值：

  def sum(number1, number2):return number1 + number2print(sum(2, 5))
  

• 函数返回值之 None 类型：

  思考：如果函数没有使用 return 语句返回数据，那么函数有返回值吗？答案是有的。
  py 中有一个特殊的字面量：None，其类型是：<class ‘NoneType’> 无返回值的函数，实际上就是返回了：None 这个字面量。

  def say_hi():
  print("你好呀")result = say_hi() # 你好呀
  print(f"无返回值函数，返回的内容是：{result}") # 无返回值函数，返回的内容是：None
  print(f"无返回值函数，返回的内容类型是：{type(result)}") # 无返回值函数，返回的内容类型是：<class 'NoneType'>
  

十五、global 关键字

定义在函数外的为全局变量，定义在函数内的为局部变量。如果在函数内直接修改全局变量，不能成功，但是使用 global 关键字，可以使函数内部声明的变量为全局变量，这样才能修改成功。

• 不使用 global 关键字：

  x = 10def fun():x = 20fun()
  print(x) # 10
  

• 使用 global 关键字：

  x = 10def fun():global xx = 20fun()
  print(x) # 20
  

十六、python 数据容器

数据容器有如下特点：

• 是否支持重复元素
• 是否可以修改
• 是否有序，等

数据容器分为 5 类：列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）。

1、列表（list）

基本语法：

# 字面量
[元素1、元素2、元素3、元素4，...]# 定义变量
变量名称 = [元素1、元素2、元素3、元素4，...]# 定义空列表
变量名称 = []
定义变量 = list()

案例：

student_list = ["张三", "李四", "王五", "赵六"] # 该list不同于java，不受泛型限制
for i in range(0, len(student_list)):print(student_list[i]) # 遍历打印

test_list = ["张三", 1, True, False, [1,2,3]] # 该list不同于java，不受泛型限制,也可以存入嵌套列表
for i in range(0, len(test_list)):print(test_list[i]) # 遍历打印

tips：元素下标：
如果是从左往右，则是0开始递增（0，1，2，3…）；
如果是从右边开始，则是从-1开始依次往左边递减（…-5，-4，-3，-2，-1）。

在 python 中，如果将函数定义为 class（类）的成员，那么函数会称之为：方法

def add(x, y):									class Student:return x + y                                	def add(self, x, y)return x + y函数												  方法	

• 函数的使用：
  num = add(1, 2)

• 方法的使用：
  student = Student()
  num = student.add(1, 2)

1、列表插入元素：

test_list.insert(1, "李四") # 在下标为 1 的位置插入元素

2、追加元素：追加元素是加在末尾

test_list.append("王五")

3、将一个列表添加到新的列表：

test_list = ["张三", 1, True, False, [1,2,3]]
test_list2 = ["李四", "王五"]
test_list.extend(test_list2)for i in range(0, len(test_list)):print(test_list[i]) # 遍历打印

4、列表删除元素-语法一：

del test_list[index] # index 为下标

5、列表删除元素-语法二：

test_list.pop(index) # index 为下标

6、删除某个指定的元素：（但是只能删除第一个元素，后续如果有相同的元素需要多次调用 remove 方法）

test_list.remove("张三") # 张三为具体的元素值

7、清空 list 列表：

test_list.clear()

8、统计 list 列表中某个元素值的数量：

test_list.count("张三") # 统计张三这个元素出现的次数

总结：

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

2、元组（tuple）

元组内的元素不可以被修改。

元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。

# 字面量，里面的元素不受泛型控制
(元素、元素、元素...元素)
# 定义元组变量
变量名称 = (元素、元素、元素...元素)
# 定义空元组
变量名称 = ()         # 方式一
变量名称 = tuple()    # 方式二

如果元组内只有一个元素，需打上一个空的逗号：

# 正确实例
t1 = ("张三", )
# 错误示例
t1 = ("张三")

元组的操作方法：

index()	查找某个数据，如果存在就返回对应的下标，不存在就报错
count()	统计某个数据在当前元组出现的次数
len(元组)	统计元组内的元素个数

3、字符串

py 中字符串与 java 相差不大，py 中字符串存在的一个特点就是，字符串下标从左往右是从 0 开始，从右往左是从 -1 开始。
也就是要获取一个字符串最后一个字符，可以这样获取：str[-1]。

tips：字符串中的字符也不支持修改，但是可以使用 replace 替换后赋值给新的一个字符串，旧字符串不变，仅支持查看。

str1 = "hello world"
str2 = str1 .replace("hello", "hi")print(str1) # hello world
print(str2) # hi world

字符串常用操作：

replace()	替换子字符串
splitt()	将字符串以某个字符分割，存入列表中
strip()	字符串.strip()，去除字符串前后空格
strip(“子字符串”)	去除字符串中子字符串的字符
count(“子字符串”)	统计字符串某个子字符串或字符出现的次数
len(“字符串”)	统计字符串的长度

4、序列切片

序列是指：内容连续、有序、可使用下标索引的一类数据容器。列表、字符串、元组均可视为序列。
切片：从一个序列中取出一个子序列。

语法：序列[起始下标：结束下标：步长]

tips：起始下标包含，结束下标不包含。类似于[其实下标，结束下标)。

# 以list举例
list = [1, 2, 3, 4, 5, 6, 7]print(list[0:4:2]) # [1,3]
print(list[0:4])   # [1,2,3,4]，不指定步长默认就是1
print(list[::])    # [1, 2, 3, 4, 5, 6, 7]，不写起始，也不写结束、步长，就默认打印全部
print(list[::2])   # [1, 3, 5, 7]，末尾的7包含
print(list[::-1])  # [7, 6, 5, 4, 3, 2, 1]，步长为-1，表示从倒序打印

5、集合

py 中集合和 java 中类似，无序不重复。

语法：

# 定义集合字面量
{元素，元素，元素，...，元素}
# 定义集合变量
变量名称 = {元素，元素，元素，...，元素}
# 定义空集合
变量名称 = set()

set 集合常用方法：

add(“e”)	添加新元素
remove(“e”)	删除元素
pop()	随机取出一个元素
clear()	清空集合
set3 = set1.difference(set2)	取 set1 和 set2 两个集合的差集，存进 set3
set1.difference_update(set2)	在 set1 内，删除 set2 中相同的元素
set3 = set1.union(set2)	合并 set1 和 set2，存入 set3
len()	统计集合中的元素

6、字典

# 定义字典
my_dict = {"王力宏":99, "周杰伦":88, "林俊杰":77...}
# 定义空字典
my_dict2 = {}
my_dict3 = dict()
# 定义嵌套字典
stu_score_dict = {"王力宏":{"语文":77, "数学":88, "英语": 66},"周杰伦":{"语文":78, "数学":45, "英语": 90},"林俊杰":{"语文":82, "数学":33, "英语": 88}
}

取王力宏的语文成绩：score = stu_score_dict[“王力宏”][“语文”]
取王力宏的所有数据：score = stu_score_dict[“王力宏”]

常用操作：

dict = {“张三”:1, “李四”:2, “王五”:3}

dict[“赵六”:4]	添加新元素（如果存在就是更新操作）
dict.pop(key)	删除元素
dict.clear()	清空元素
dict.keys()	获取全部 key
len(dict)	统计字典内的元素数量

7、数据容器总结

-----------------	列表	元组	字符串	集合	字典
元素数量	支持多个	支持多个	支持多个	支持多个	支持多个
元素类型	任意	任意	仅字符	任意	value：任意类型
下标索引	支持	支持	支持	不支持	不支持
重复元素	支持	支持	支持	不支持	不支持
可修改性	支持	不支持	不支持	支持	支持
数据有序	是	是	是	否	否
使用场景	可修改、可重复的一批数据记录场景	不可修改、可重复的一批数据记录场景	一串字符的记录场景	不可重复的数据记录场景	以key检索value的数据记录场景

容器通用操作：

• len()：元素个数。

• max()：最大元素。

• min()：最小元素。

• 类型转换：

  • 容器转列表： list()
  • 容器转元组：tuple()
  • 容器转字符串：str()
  • 容器转集合：set()

• 容器排序：sorted(容器，reverse=true)，统一转为列表对象。

十七、函数相关

• 函数多返回值：

def test_return():return 1,2x,y = test_return()
print(x) # 1
print(y) # 2

• 函数传参：

def user_info(name, age, gender):print(f"您的名字是：{name}, 年龄是：{age}, 性别是：{gender}")# 关键字传参
user_info(name="张三", age=20, gender="男")
# 可以不安固定顺序传参
user_info(age=20, name="张三", gender="男")

• 缺省参数：缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注：所有位置参数必须出现在默认参数前，包括函数定义和调用）。

def user_info(name, age, gender="男"):print(f"您的名字是：{name}, 年龄是：{age}, 性别是：{gender}")user_info(name="张三", age=20)
user_info(name="张三", age=20, gender="女")

• 不定长参数：不定长参数也叫可变参数，用于不确定调用的时候会传递多少个参数的场景（或者不传参）。

  • 位置不定长： 不能传递键值对。

  注意：传进的所有参数都会被 args 变量收集，它会根据传进参数的位置合并为一个元组（tuple），args 是元组类型，这就是位置传递。

  def user_info(*args):print(args)user_info('TOM') # ('张三',)
  user_info('TOM', 18) # ('张三', 18)
  

  • 关键字传递：必须传递键值对。

  def user_info(**kwargs):print(kwargs)
  user_info(name="张三", age=20, gender="女") # {'name': '张三', 'age': 20, 'gender': '女'}
  

  注意：参数是 key-value 形式的情况下，所有的键-值都会被 kwargs 接收，同时会根据键-值组成字典（dict）。
  
  

• 函数中传递函数参数：

def test_fun(compute) # 把函数作为参数传入result = compute(1,2)print(result)def compute(x, y)return x + y

十八、lambda 匿名函数

def test_fun(compute): # 把函数作为参数传入result = compute(1, 4)print(result)# 对于 compute 函数，采用匿名函数代替
test_fun(lambda x, y: x + y)

十九、文件读取操作

在 python 中，使用 open 函数，可以打开一个已经存在的文件，或者创建一个新文件，语法如下：

# name：是要打开的目录文件名的字符串（可以包含文件所在的具体路径）
# mode：设置打开文件的模式：只读、写入、追加等。
# encoding：编码格式（推荐使用 UTF-8）
open(name, mode, encoding) 

mode 常用的三种基础访问模式：

• r：以只读方式打开文件，文件的指针将会放在文件的开头，这是默认模式。
• w：打开一个文件只用于写入，如果该文件已存在则打开，如果文件不存在，则创建文件。
• a：打开一个文件用于追加，如果该文件已存在，新的内容将会被写入到已有内容之后，如果该文件不存在，创建新文件进行写入。

open() 函数常用方法：

• read(num)：读取文件，num 表示要读取的数据长度。
• readlines(num)：以行的方式对整个文件中的内容进行一次性读取，并且返回一个列表，其中每行数据为一个元素。
• readline()：每次读取一行。

示例：

f = open("F:/Study/py/test.txt", "r", encoding="UTF-8")
print(f.readlines()) # 以行读取存入列表