代码收藏家 python学习笔记：基础语法
目录
python语言概述
python是一种解释型的语言，这意味着开发过程中没有了编译这个环节，和C的shell类似，是一种交互性语言，是一种面向对象的语言，这表示python支持面向对象的风格或代码封装在对象的编程技术，是一种初学者的语言，它支持广泛的应用程序开发，从简单的文字处理到WWW浏览器和游戏，常用于人工智能，web应用，爬虫程序，大数据等方面。
python基础语法
1.注释
单行注释，以#开头
多行注释，以'''开头，'''结尾
注意：使用缩进取代逻辑或者函数后面{}包含内容，所有内部代码缩进必须相同
2.输出print
print(*values，sep=' ',end='\n',file=sys.stdout,flush=False)
values:要打印的值
sep:表示要输入多个打印的值时，各个值之间分割方式，默认空格间隔
end:控制print传入值输出完后结束符号，默认换行
file:设置输出对象，即把print中的值打印到什么地方
基本用法代码示例：
a = 12
b = 'abc'
c = "hello"
print(a, b, c)
print("a: ", a)
print("b: ", b, "c: ", c)
# 使用格式化控制符
print("a: %d" % a)
print("b: %s c: %s " % (b, c))
# 像QString的arg方法,使用字符串的format方法
print("a : {} b: {} c: {}".format(a, b, c))
print("a : {2} b: {1} c: {0}".format(a, b, c))
# 修改print函数的默认参数,去除多数值简答的间隔
print(a, b, c, sep="")
运行结果如上
3.输入–input（）
input接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型并且只能输入一个
用法代码示例：
a = input()
a = input("请输入： ")
print(a)
type():返回a的类型
print("a type is", type(a))
b = int(input("请输入： ")) # int() 类型强制转换
print(b)
print("b type is", type(b))
input不能进行多个输入，将所有输入默认为字符串处理，并返回字符串
4.变量赋值
1.变量赋值，用=（注意加空格）
2.多变量同时赋值一个类型的数值
a = b = c = 1
3.多变量同时赋值不同类型的赋值
a, b, c =1, "hello", 2注意：和C语言不一样，在python中变量更像是附在对象上的标签（和引用类似）。当变量被绑定在一个对象上时，该变量的引用计数就是1，系统会定时扫描，当某个标签应勇计数为0，该对象就会被系统回收。
看看代码进行理解把：
a, b, c = 1, "hello", 2
print(a, b, c)
a = b = c = 1 # 为数值1 开辟空间，再给空间取别名为 a,b,c
print(a, b, c)
# id() :求变量地址
print(id(a), id(b), id(c))
b = 3
print(id(a), id(b))a, b, c = 1, "hello", 2
print(a, b, c)
从运行结果可以验证我们上述的说法，当我们对多变量赋值相同时，打印他们的地址会发现这些变量的地址都是相同的。
python标准数据类型
（1）数字类型 Number:可以是整数，浮点，复数complex等数据
（2）字符串类型 Str/bytes：文本字符串/字节字符串
（3）列表类型 List : 使用【】进行表示，列表元素可变
（4）元组类型 Tuple：使用（）进行标识，元组元素只可读
（5）字典类型 dict:使用{}进行标识 key:vlaue 键值对，字典元素值可变
数据类型分为不可变类型（数字，字符串，元组（），不可变集合）和可变类型（列表【】，字典 {}，可变集合）
不可变类型：不支持原处修改
可变类型：可以通过操作原处修改，而不用创建新的对象
1.数字类型
整型（int）通常用0b 0o 0x分别表示二进制，8进制，16进制，浮点型通常由整数部分和小数部分组成，复数由实数部分和虚数部分，可以用a+bj或者complex(a,b)表示，实部和虚部都为浮点型
# 导入math库中的ceil函数 floor函数，到当前脚本中
from math import ceil, floor
a = -5
print(abs(a)) # abs:求绝对值
b = 2.8
print(ceil(b)) # ceil():向上取整
print(floor(b)) # floor():向下取整
# 从random随机数的库中，导入randrange函数
from random import randrange, randint, uniform
# randrange([start],stop, [step]): 开始，结束，步长，必须满足左闭右开
c = randrange(1, 5, 2) # 产生随机数
print("c: ", c)
d = randint(1, 6) # 产生随机的整数，无步长限制
print("d: ", d)
e = uniform(0, 1) # 产生随机的浮点数（0，1）
print("e: ", e)
数字类型转换：
int(x):将x转换为一个整数
float(x)：将x转换到一个浮点数
complex(x)：将x转换到一个复数，实数部分为x,虚数部分为0
complex(x,y)：将x和y转换到一个复数，实数部分为x,虚数部分为y.
数学函数：
随机函数
2.字符串类型
python语言有两种不同的字符串
1.string:一个用于存储文本（字符），文本字符串内部使用unicode存储
2.bytes:一个用于存储原始字节（二进制），字节字符串存储原始字节并显示ASCII
.字符串中的切片
切片是指对操作对象截取其中一部分的操作，语法：【起始：结束：步长】左闭右开
"""
1.str: 字符串类型，用于存储文本数据，也就是字符
2.bytes:字符串类型，用于存储字节数据，也就是二进制
"""
text_str = "hello world"
byte_str = b"hello world"
print(type(text_str), type(byte_str))
print(text_str, byte_str)
'''
字符串数据的访问：【i】
'''
print(text_str[4])
"""
字符串的切片:[start:stop:step] 左闭右开，默认步长为1
"""
text_str = "hello world"
print(text_str[2: 5])
print(text_str[: 3]) # 默认从0下标开始
print(text_str[: -1]) # 从下标0开始，-1最后一个元素下标
print(text_str[:: 2]) # 从头到尾，步长为2
字符串的运算 ：+表示字符串的拼接
"""
字符串的运算：
1. +:字符串的拼接
2. *n:字符串重复n次
"""
print(text_str + "welcome")
print(text_str*3)
"""
字符串函数
1.len:求字符串长度
2.find:检测子串
3.index:和find一样
4.count:返回字符串在start和end之间在另一个字符串里出现的次数
5.replace:把字符串中的子串替换成新的字符串
"""
print(len(text_str))
3.列表类型
定义格式：列表名字 = 【元素1，元素2，……………】
元素可以是任意类型的，字符，数字，字符串，列表等等
元素获取通过下标来进行索引
list1 = [1, 2, "one"]
list2 = [1, 2, "one", [1, 3, "two"], list1]
print(list1[0], list1[2])
print(list1[2][2])
print(list2[3][2])
列表元素也可以进行切片：
"""
列表元素可以切片
"""
print(list2[1: 4])看看结果：
对列表元素进行修改：
"""
列表元素的修改
"""
list1[1] = 234
list1[2] = "three"
print(list1)看看结果：
列表的一些常用函数：
list3 = []
for i in range(10):
list3.append(i) # 向列表末尾追加元素
print(list3)
list3.insert(3, 120) # 向列表中3这个下标插入元素 120
list3.insert(3, "three")
print(list3)
list4 = [5, 4, 3, 2, 1]
list4.sort() # 将列表中的元素进行排序,默认升序
print(list4)
print(max(list4)) # 求列表中的最大值
看看运行结果：
列表的运算：
"""
列表的运算
"""
# []+[] 将两个列表相加就是将两个列表元素进行拼接，形成新的列表
print([1, 2, 4] + [4, 5, 6])
# 【】* n ,就是将列表元素重复n次，拼接成新的列表
print([1, 2, 3] * 3)
接下来我用一张图总结一下列表的相关函数：
4.元组
元组类似于list，用（）标识，内部元素用逗号隔开，但是元组不能进行而二次赋值，也就是不可修改，相当于只读列表。
"""
元组tuple类型，（）标识，元素值不可变，使用方式和list一样
"""
# t = () 定义一个空的元组，但是没有任何意义，因为元组元素不能修改
t = (1, 3, "one", [3, 4], ([1, 2], "two"))
print(t)
print(t[2])
print(t[3][1])
print(t[4][0][1])
# t[0]=2 错误 元组元素不能修改
# t[2][1]= "3" 字符串元素不能修改
t[3][0] = 2 # 列表可以修改
print(t)
5.字典
1.无序的对象集合
2.用“{ }”标识
3.字典由索引key和他对应的值value组成，key可以是数字类型也可以是字符串类型，value可以是任意类型。
4.字典元素的访问 【key】
"""
字典dict类型， {key:value ， key:value}标识
元素为键值对
key只能是number 或 str类型
value:可以是任意的类型
"""
# dic = {} # 定义一个空字典
dic = {1: "one", "two": 2, 3: [1, 2, 3], "for": {1: "one", 2: "two"}}
print(dic)
"""
字典元素的访问 【key】
"""
print(dic[1])
print(dic["two"])
print(dic[3][1])
"""
字典元素的修改
"""
dic[1] = "three"
print(dic)
"""
字典元素的新增：【newKey】=value
"""
dic["new"] = 1234
print(dic)
python基础语法
1.条件判断语句
"""
注意结构语句：用：和缩进代替{}结构，相同缩进的代码行处于同一个结构中
1.判断语句
if 表达式：
结构语句
elif 表达式：
结构语句
else:
结构语句
a, b = 23, 25
if a > b:
print("a is max")
else:
print("b is max")
print("b is max")
2.循环语句
for 循环：
for 变量 in 单词表：
结构语句
表示每循环一次，变量就取单词表中的一个数据
1.单词表可以是多个任意类型的数据组成，数据之间用逗号隔开
2.单词 表也可以是一片连续的数字类型，用range()生成
3.单词表可以是 列表类型，每循环一次，变量取列表中的一个元素
for i in 1, 25, "one", [1, 2, 3], (3, 2), {1: 2}:
print(i, end=" ")
print()
for i in range(10):
print(i, end=" ")
print()
for i in [1, 2, 3, 4, 5, 6, 7]:
print(i, end=" ")
print()
"""
while循环
python中没有i++ ,i--
"""
i = 0
while i < 10:
print(i, end=" ")
i += 1
print()
3.函数
def 函数名（形参列表）
函数体
return
def为函数说明的关键字
形参列表中，可以有一个，多个或者没有参数，多个参数以逗号隔开
参数：说明函数时，形参没有数据类型，当调用时根据实参的类型来决定
函数可以有返回值，可以同时返回多个数据，返回值可以是任意类型
# 函数的说明
def add(x):
print("type: ", type(x))
return x + 1
# 函数的调用
res = add(3)
print(res)# 返回多个数值，以逗号隔开，调用时就需要定义多个变量来保存相应的返回值
def add(x, y):
return x + y
print(add(3, 4))
print(add([1, 3], [2, 3]))
def swap(x, y):
return y, x
x, y = swap(2, 3)
print(x, y)
x, y = swap((1, 3, 4), [4, 5, 6])
print(x, y)来看看结果：
匿名函数和朗达表达书
匿名函数：lambda表达式 (lambda a1, a2... : value)(arg1,arg2...) 注意： 1.调用匿名函数时，将arg1传递给a1,arg2给a2 2.该表达式返回value数值 3.a1,a2代表原函数的形参，多个形参以逗号隔开 4.value代表原函数的返回值
def func(x):
return x + 1
a = lambda x: x + 1
print(func(3))
print(a(3))
print((lambda x: x+1)(3))
# def func(x, y):
# return x + y
print((lambda x, y: x + y)(1, 5))
# print((lambda x, y: y, x)(1, 5)) 错误返回值是元组类型，不能被当成函数调用
# lamdba 表达式不能返回两个数值
扩展：列表推导式
"""
列表推导式
"""
# 定义列表，元素为i,而i会随着循环取值，循环多少次，那么i值就有多少个，列表元素就有多少个
list1 = [i for i in range(11)]
print(list1)
# 定义列表，元素j，当每次循环j从单词表中取值，并满足j为偶数时，j才会作为列表元素
list1 = [j for j in range(101) if j % 2 ==0]
print(list1)
# 定义一个列表，将0-11之间数据的两倍写入列表中
list1 = [k*2 for k in range(12)]
print(list1)
内函数和匿名函数的应用
"""
内函数和匿名函数的应用
"""
list1 = [('d', 1), ('c', 2), ('b', 3), ('a', 4)]
# key:表示排序的依据，lambda表达式中，x代表列表的每个元素，表达式返回x[0]作为排序的条件
list2 = sorted(list1, key=lambda x: x[0])
print(list2)
list2.sort(key=lambda x: x[1])
print(list2) 
"""
普通用法
"""
def sq(x):
return x**2
# map函数，将第二参数的结果作为第一参数的输入，将输出数据的地址返回出来
a = map(sq, [i for i in range(10)])
print(a)
# list()将地址强转为list类型,print打印之后，地址上的数据被清空
print(list(a))
b = map(lambda x: x**2, [i for i in range(10)])
print(list(b))
4.全局变量和局部变量
a = 5 # 全局变量
def func():
global a # 说明该函数中，使用全局变量a
a = 4 # 局部变量
func()
print(a)
