笔者在C语言基础上学习python自用笔记

type() 返回数据类型

name = "root"
hei = 1.8
wei = 77
type_hei = type(hei)
type_wei = type(wei)
print(type(name))
print(type_hei)
print(type_wei)

在python中变量是没有类型的，它存储的数据是有类型的。

数据类型转换：Python 笔记 — 数据类型转换

字符串

字符串三种定义方式：

1. 单引号
2. 双引号
3. 三引号：三引号的写法和多行注释一样，如果把它赋给一个变量接收，那它就是字符串

引号的嵌套

#单引号内可以写双引号
name = '"root"'
print(name)
#双引号内可以写单引号
name = "'root'"
print(name)
#使用\来转义
name = "\"root\""
print(name)
name = '\'root\''
print(name)

字符串拼接

name = "root"
num = 1729
print("my name is "+ name + ",do you know me?"+ str(num) + " is an interesting number.")

字符串格式化

类似于C语言

hei = 1.8
wei = 77
print("my height is %s,my weight is %s" % (hei , wei) )
#这里是将浮点型和整型转为了字符型，当然你也可以这样写
print("my height is %f,my weight is %d" % (hei , wei) )

数字精度控制

使用m.n来控制数据的宽度和精度

• m，控制宽度，设置的宽度小于数字自身，不生效
• n，控制小数点精度，会进行小数的四舍五入

示例：

• %5d：表示将整数的宽度控制在5位，如数字11，被设置为5d，就会变成：[空格] [空格] [空格] 11，用三个空格补足宽度
• %5.2f：表示将宽度控制为5，将小数点精度设置为2；小数点和小数部分也算入宽度计算。如：对11.345设置了%7.2f后，结果是：[空格] [空格] 11.35，2个空格补足宽度，小数部分限制2位精度后，四舍五入为.35
• %.2f：表示不限制宽度，只设置小数点精度为2，如11.345设置%.2f后，结果是11.35

格式化快速写法：f"内容{变量}"

name = "root"
hei = 1.8
wei = 77
print(f"my name is {name},my height is {hei},my weight is {wei}.")
#不做精度控制

输入

print("请告诉我你是谁？")
name = input()
print("我知道了，你是%s" % (name))
#可以直接这样写：
name = input("请告诉我你是谁？")
print("我知道了，你是%s" % (name))

input默认把输入的数据视为字符串类型

判断

age = 25
#age = 15
print(f"已经{age}岁了")
if age>=18 :print("成年了")print("该扛起重担了")
else:print("珍惜时光吧")
print("时间过得真快")

注意缩进，不同的缩进处于不同的级下；根据age的不同观察结果的不同

if_elif_else

score=70
if score>=80 :print("优秀")
elif score>=60 :print("及格")
else :print("不及格")

循环

while

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

for

格式：

for 临时变量 in 待处理数据集:循环满足条件时执行的代码

实例：

name = "root"
for x in name:print(x)

待处理数据集严格来说称之为序列类型（其内容可以一个个依次取出的一种类型）包括字符串、列表、元组等。

range

range(num)：获取一个从0开始，到num结束的数字序列(不含num本身)
如range(5)取得的数据是：[0,1,2,3,4]

range(num1,num2)：获取一个从num1开始，到num2结束的数字序列(不含num2本身)
如range(5,10)取得的数据是：[5,6,7,8,9]

range(num1,num2,step)：获取一个从num1开始，到num2结束的数字序列(不含num2本身)，数字之间的步长为step
如range(5,10,2)取得的数据是：[5,7,9]

for x in range(0,20,3):print(x)

函数

定义：

def 函数名(传入参数):函数体return 返回值

字面量None 类型：<class ‘NoneType’>

无返回值的函数，实际上就是返回了None这个字面量

None可用于if判断，相当于false

def check_age(age):if age >= 18:return "SUCCESS"else:return None
result = check_age(16)
if not result:print("不能进入！")

None可用于声明无初始内容的变量

name = None

函数的说明文档：在def语句的下面进行多行注释会自动生成

使用global关键字可以在函数内部声明变量为全局变量

num = 100
def testA():print(num)def testB():#global numnum = 200print(num)testA()
testB()
print(num)

如果一个函数要有多个返回值，该如何书写代码？

按照返回值的顺序，写对应顺序的多个变量接收即可

变量之间用逗号隔开

支持不同类型的数据return

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

函数参数种类

位置参数：调用函数时根据函数定义的参数位置来传递参数

def user_info(name,age,gender):print(f"您的名字是{name},年龄是{age},性别是{gender}")
user_info('root',25,'女')

注意：传递的参数和定义的参数的顺序及个数必须一致

关键字参数：调用函数时通过“键=值”的形式传递参数

作用：可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求

def user_info(name,age,gender):print(f"您的名字是{name},年龄是{age},性别是{gender}")
user_info(age=25,gender="女",name="root")
#可以和位置参数混用，位置参数必须在前，且匹配参数顺序
user_info("root",age=25,gender="女")

缺省参数:也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值

注意：所有位置参数必须出现在默认参数前，包括函数定义和调用

作用：当调用函数时没有传递参数，就会使用默认是缺省参数对应的值

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

不定长参数:也叫可变参数，用于不确定调用的时候会传递多少个参数(不传参也可以)的场景

作用：当调用函数时不确定参数个数，可以使用不定长参数

类型：1.位置传递 2.关键字传递

1.位置传递

def user_info(*info):print(info)
user_info("root")
user_info("root",25,"女")

输出结果：

('root',)
('root', 25, '女')

参数可以传任意个，传进的所有参数都会被info变量收集，它会根据传进参数的位置合并为一个元组

2.关键字传递

传递的参数为“键=值”的形式，会合并为一个字典

def user_info(**info):print(info)
user_info(name="root")
user_info(name="root",age=25,gender="女")

输出结果：

{'name': 'root'}
{'name': 'root', 'age': 25, 'gender': '女'}

函数作为参数传递

def test_func(compute):result = compute(1,2)print(type(compute))print(result)
def compute(x,y):return x+y
test_func(compute)

输出结果：

<class 'function'>
3

lambda匿名函数

• def关键字，可以定义带有名称的函数

• lambda关键字，可以定义匿名函数(无名称)

• 有名称的函数，可以基于名称重复使用

• 无名称的匿名函数，只可临时使用一次

定义语法：lambda 传入参数: 函数体(一行代码)

上述代码可以写成

def test_func(compute):result = compute(1,2)print(type(compute))print(result)
test_func(lambda x,y:x+y)

数据容器

列表(list)

列表的定义

name_list = ["C++","Python","Java"]
print(name_list)
print(type(name_list))
#列表存储的数据类型可以不一样
#嵌套列表：
my_list = [["root",1.8,77],["嵌套",[1729,3.14]]]
print(my_list)

列表的下标索引

name_list = ["C++","Python","Java"]
print(name_list[0])
print(name_list[1])
print(name_list[2])
print(name_list[-1])
print(name_list[-2])
print(name_list[-3])
my_list = [["root",1.8,77],["嵌套",[1729,3.14]]]
print(my_list[0][1])
print(my_list[1][0])
print(my_list[1][1][1])

输出结果：

C++
Python
Java
Java
Python
C++
1.8
嵌套
3.14

列表的方法

列表.index(元素)

查找指定元素在列表的下标，如果找不到，报错ValueError

name_list = ["C++","Python","Java"]
print(name_list.index("C++"))
#print(name_list.index("php"))

列表[下标]=值

重新赋值

name_list = ["C++","Python","Java"]
name_list[0]="php"
print(name_list)

列表.insert(下标,元素)

在指定的下标位置插入指定的元素

name_list = ["C++","Python","Java"]
name_list.insert(1,"php")
print(name_list)

列表.append(元素)

将指定元素追加到列表的尾部

name_list = ["C++","Python","Java"]
name_list.append("php")
print(name_list)

列表.extend(其他数据容器)

将其他数据容器的内容取出，依次追加到列表尾部

name_list = ["刘备","关羽","张飞"]
name_list.extend(["诸葛亮","赵云","马超"])
print(name_list)

删除元素

• del 列表[下标]
• 列表.pop(下标)

name_list = ["刘备","关羽","张飞","诸葛亮","赵云","马超"]
del name_list[5]
print(name_list)
element = name_list.pop(4)
print(element)
print(name_list)

列表.remove(元素)

删除某元素在列表中的第一个匹配项

name_list = ["刘备","关羽","张飞","诸葛亮","张飞","马超"]
name_list.remove("张飞")
print(name_list)

列表.clear()

清空列表

name_list = ["刘备","关羽","张飞"]
name_list.clear()
print(name_list)

列表.count(元素)

统计某元素在列表内的数量

name_list = ["刘备","关羽","张飞","诸葛亮","张飞","马超"]
print(name_list.count("张飞"))

len(容器)

统计容器内有多少元素

name_list = ["刘备","关羽","张飞","诸葛亮","张飞","马超"]
print(len(name_list))

列表的遍历

while

index = 0
name_list = ["刘备","关羽","张飞","诸葛亮","张飞","马超"]
while index < len(name_list) :print(name_list[index])index += 1

for

name_list = ["刘备","关羽","张飞","诸葛亮","张飞","马超"]
for element in name_list:print(element)

元组(tuple)

元组的定义

元组在定义之后不可更改数据，可以理解为只读的list

比如，我们想存储桃园三结义的人物，肯定就是下面这三个；我们不希望它能被更改，改成”刘备、孙权、曹操“就不好了。这时候就要用到元组(tuple)

name_tuple = ("刘备","关羽","张飞")
print(type(name_tuple))
print(f"桃园三结义的是{name_tuple}")
#定义空元组
t1 = ()
t2 = tuple()
#元组只有一个数据时，这个数据后面要添加逗号
t3 = ('only',)
#嵌套元组：
three_country = (("曹操","曹丕","曹冲"),("刘备","刘禅"),("孙坚","孙策","孙权"))
print(three_country)
print(three_country[1][1])

元组内存储列表时，列表的内容可以改变

t4 = (1729,3.14,["root","smile"])
t4[2][1] = "cry"
print(t4)

方法等参照列表

字符串(str)

• 字符串支持下标索引
• 字符串不能被修改

字符串.replace(字符串1,字符串2)

将字符串内的全部“字符串1”替换为“字符串2”

注意：并非修改字符串本身，而是得到了一个新的字符串

str1 = "happy sad scared mad"
print(str1.index("sad"))
str2 = str1.replace("ad","da")
print(str1)
print(str2)

输出结果：

6
happy sad scared mad
happy sda scared mda

字符串.split(分隔符字符串)

按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

注意：字符串本身不变，而是得到了一个列表对象

str3 = "apple,banana,pear,peach,mango"
list_str3 = str3.split(",")
print(str3)
print(list_str3)

输出结果：

apple,banana,pear,peach,mango
['apple', 'banana', 'pear', 'peach', 'mango']

字符串的规整操作

• 字符串.strip()：去前后空格
• 字符串.strip(字符串)：去前后指定字符串

str4 = " I have never let my schooling interfere with my education. "
str4_c = str4.strip()
str5 = "12I have never let my schooling interfere with my education.21"
str5_c = str5.strip("12")
#并非完全按照"12"，而是满足其子串"1""2"就会去除
print(str4)
print(str4_c)
print(str5)
print(str5_c)

输出结果：

 I have never let my schooling interfere with my education. 
I have never let my schooling interfere with my education.
12I have never let my schooling interfere with my education.21
I have never let my schooling interfere with my education.

序列

序列是指：内容连续、有序，可使用下标索引的一类数据容器

列表、元组、字符串，均可以视为序列

切片：从一个序列中，取出一个子序列

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

表示从序列中的指定位置开始，依次取出元素，到指定位置结束，得到一个新序列

起始下标表示从何处开始，可以留空，留空视作从头开始

结束下标表示何处结束(不包含此下标)，可以留空，留空视作截取到结尾

步长表示依次取出元素的间隔

• 步长1表示，一个个取元素(可以省略)
• 步长2表示，每次跳过1个元素取
• 步长N表示，每次跳过N-1个元素取
• 步长为负数表示，反向取(注意，起始和结束下标也要反向标记)

切片的操作并不会影响序列本身，而是会得到一个新的序列

my_list = ["a",1,2,3,3.14]
qie_list = my_list[1:4]
my_tuple = (4,5,6,7,8)
qie_tuple = my_tuple[:]
my_str = "lexicographer"
qie_str = my_str[-1:-10:-3]
print(qie_list)
print(qie_tuple)
print(qie_str)

输出结果：

[1, 2, 3]
(4, 5, 6, 7, 8)
rpg

集合(set)

集合的定义

set1 = set() #定义空集合
set1 = {"C++","Java","Python","C++","Java"}
print(set1)
print(type(set1))

输出结果：

{'C++', 'Java', 'Python'}
<class 'set'>

• 集合是无序的，所以不支持下标索引访问
• 集合是允许修改的

集合的操作

set1 = {"C++","Java","Python","C++","Java"}
#添加新元素
set1.add("php")
set1.add("C++")
print(set1) #输出结果：{'Python', 'Java', 'C++', 'php'}
#移除元素
set1.remove("Java")
print(set1) #输出结果：{'C++', 'Python', 'php'}
#随机取出一个元素
element = set1.pop()
print(element)
print(set1)
print(len(set1))
#清空集合
set1.clear()
print(set1) #输出结果：set()

集合1.difference(集合2)

取出集合1和集合2的差集(集合1有而集合2没有的)，得到一个新集合，集合1和2不变

set1 = {1,2,3,4}
set2 = {3,4,5,6}
set3 = set1.difference(set2)
print(set1)
print(set2)
print(set3)

输出结果：

{1, 2, 3, 4}
{3, 4, 5, 6}
{1, 2}

集合1.difference_update(集合2)

在集合1内，删除和集合2相同的元素；集合1被修改，集合2不变

set1 = {1,2,3,4}
set2 = {3,4,5,6}
set1.difference_update(set2)
print(set1)
print(set2)

输出结果：

{1, 2}
{3, 4, 5, 6}

集合1.union(集合2)

将集合1和集合2组成新集合；得到新集合，集合1和2不变

set1 = {1,2,3,4}
set2 = {3,4,5,6}
set3 = set1.union(set2)
print(set1)
print(set2)
print(set3)

输出结果：

{1, 2, 3, 4}
{3, 4, 5, 6}
{1, 2, 3, 4, 5, 6}

集合的遍历

因为集合不支持下标索引，所以不能用while循环

set1 = {1,2,3,4}
for element in set1:print(element)

字典(dict)

字典的定义

字典的定义同样使用{}，不过存储的元素是一个个的“键值对”(key : value)

dict1 = {} #定义空字典
#也可以这样：dict1 = dict()
print(dict1)
dict1 = {"李雷":88,"韩梅梅":90,"李华":99}
print(dict1)
print(type(dict1))

输出结果：

{}
{'李雷': 88, '韩梅梅': 90, '李华': 99}
<class 'dict'>

字典的key是不可以重复的

dict1 = {"李雷":88,"韩梅梅":90,"李华":99,"韩梅梅":95}
print(dict1)

输出结果：

{'李雷': 88, '韩梅梅': 95, '李华': 99}

字典也不可以使用下标索引，但可以通过key值来取得对应的value

dict1 = {"李雷":88,"韩梅梅":90,"李华":99}
print(dict1["李华"]) #输出结果：99

字典的key和value可以是任意数据类型(key不可为字典)

字典的嵌套

代码示例：

score = {"王力鸿": {"语文":77,"数学":66,"英语":33},"周杰轮": {"语文":88,"数学":86,"英语":55},"林俊节": {"语文":99,"数学":96,"英语":66}
}
print(score)
print(score["周杰轮"])
print(score["林俊节"]["数学"])

输出结果：

{'王力鸿': {'语文': 77, '数学': 66, '英语': 33}, '周杰轮': {'语文': 88, '数学': 86, '英语': 55}, '林俊节': {'语文': 99, '数学': 96, '英语': 66}}
{'语文': 88, '数学': 86, '英语': 55}
96

字典的操作

字典[key]=value

• key存在，即修改了value
• key不存在，即新增了元素

poem = {"李白":"诗仙","杜甫":"诗圣","李贺":"诗鬼","白居易":"诗魔"
}
poem["王维"] = "诗佛"
print(poem)
poem["李白"] = "天生我材必有用，千金散尽还复来"
print(poem)

输出结果：

{'李白': '诗仙', '杜甫': '诗圣', '李贺': '诗鬼', '白居易': '诗魔', '王维': '诗佛'}
{'李白': '天生我材必有用，千金散尽还复来', '杜甫': '诗圣', '李贺': '诗鬼', '白居易': '诗魔', '王维': '诗佛'}

字典.pop(key)：获得指定key的value，同时字典被修改，指定key的数据被删除

字典.clear()：清空字典

字典.keys()：返回字典中的全部key

我们可以用获取到的key对字典进行遍历

也可以直接对字典进行遍历，每一次循环都是直接得到key

代码实例：

price = {"铅笔":"1块","橡皮":"5毛","笔袋":"9块9包邮","衬衫":"9镑15便士"
}
keys = price.keys()
print(keys)
for key in keys:print(f"{key}:{price[key]}")
'''直接遍历
for key in price:print(f"{key}:{price[key]}")
'''
price_shirt = price.pop("衬衫")
print(price_shirt)
print(price)
print(len(price))
price.clear()
print(price)

输出结果：

dict_keys(['铅笔', '橡皮', '笔袋', '衬衫'])
铅笔:1块
橡皮:5毛
笔袋:9块9包邮
衬衫:9镑15便士
9镑15便士
{'铅笔': '1块', '橡皮': '5毛', '笔袋': '9块9包邮'}
3
{}

总结

各类数据容器的特点

基于各类数据容器的特点，它们的应用场景如下：

• 列表：一批数据，可修改、可重复的存储场景
• 元组：一批数据，不可修改、可重复的存储场景
• 字符串：一串字符串的存储场景
• 集合：一批数据，去重存储场景
• 字典：一批数据，可用key检索value的存储场景

数据容器通用方法

• len(容器)：统计容器的元素个数
• max(容器)：统计容器的最大元素
• min(容器)：统计容器的最小元素
• list(容器)：将给定容器转换为列表
• tuple(容器)：将给定容器转换为元组
• str(容器)：将给定容器转换为字符串
• set(容器)：将给定容器转换为集合
• sorted(容器)：对容器进行排序(升序)，结果返回列表对象
• sorted(容器,reverse=True)：对容器进行排序(降序)，升序的reverse默认=False

数据容器类型互转：

1. 对应括号的改变
2. 字符串的每个字符会被单独拿出来作为元素
3. 转集合会具有集合的特点：数据无序、不重复
4. 字典转成字符串会保留value，转成其他类型不保留

当然，动动小手敲敲代码会更好地理解