python基础

Day 1

单行注释

# 注释内容,快捷键ctrl+/

多行注释

"""
注释内容1
注释内容2
"""

'''
注释内容1
注释内容2
‘’’

查看数据类型

type()

格式化输出

print("格式化字符串" % 变量1)
print("格式化字符串" % (变量1, 变量2...))

%nd表示输出的整数显示n位，不足的地方用0补全

输出f-格式化字符串

print('我的名字是%s, 今年%s岁了' %(name,age))
print(f'我的名字是{name},今年{age}岁了'）

转义字符

\t:制表符，一个tab键（4个空格）的距离

为什么两个print会换行输出

print('输出的内容',end="\n")
在python中，print()，默认自带end="\n"这个换行符，所以导致每两个print直接会换行展示，用户可以按需求更改结束符。

输入的语法

input("提示信息")
input()函数返回的数据类型是string型

输入的特点

1. 当程序执行到input，等待用户输入，输入完成之后才继续向下执行。input("输入信息")
2. 在python中，input接收用户输入后，一般存储到变量，方便使用。a=input("输入信息")
3. 在python中，input会把接收到的任意用户输入的数据都当做字符串处理

数据类型

list=[]
tuple=()

转换数据类型的函数

int(x) 将x转换为一个整数
float(x)     将x转换为一个浮点数
str(x)       将对象转换为字符串
eval(str)    用来计算在字符串中的有效python表达式，并返回一个对象（转换成数据原本的数据类型）
tuple(s)     将序列s转换为一个元组
list(s)      将序列s转换为一个列表  

算术运算符

// 整除
** 指数
混合运算优先级顺序:() > ** > * / // % > + -

数字间的逻辑运算

and运算符，只要有一个值为0，则结果为0，否则结果为最后一个非0数字
or运算符，只要有一个值为0，则结果为0，否则结果为第一个非0数字

Day 2

if语法

if 条件:
	条件成立执行的代码1
	条件成立执行的代码2

if…else…

if 条件:
	条件成立执行的代码1
	条件成立执行的代码2
else:
	条件不成立执行的代码1
	条件不成立执行的代码2

多重判断

if 条件1:
	条件1成立执行的代码1
	条件1成立执行的代码2
elif 条件2:
	条件2成立执行的代码1
	条件2成立执行的代码2
else:
	以上条件都不成立执行的代码
	

if嵌套

if 条件1:
	条件1成立执行的代码1
	条件1成立执行的代码2
	if 条件2:
		条件2成立执行的代码1
		条件2成立执行的代码2

使用随机数

 1. 导入random模块
    import 模块名
 
 2. 使用random模块中的随机整数功能
 	random.randint(开始,结束)

三目运算符（三元运算符，三元表达式）

语法如下:
		条件成立执行的表达式 if 条件 else 条件不成立的表达式
a = 1
b = 2
c = a if a > b else b 
print(c)
运行结果:c = 2

while的语法

while 条件:
	条件成立执行的代码1
	条件成立执行的代码2

break和continue

break终止此循环，continue退出当前一次循环继而执行下一次循环代码

while嵌套

while 条件1:
	条件1成立执行的代码
	while 条件2:
	条件2成立执行的代码

for循环的执行

for 临时变量 in 序列:
重复执行的代码1
重复执行的代码2

str = 'itheima'
for i in str:
	print(i)
运行结果:
i
t
h
e
i
m
a

while…else

循环可以和else配合使用，else下方缩进的代码指的是当循环正常结束之后要执行的代码。

while 条件:
	条件成立重复执行的代码
else:
	循环正常结束之后要执行的代码

所谓else指的是循环正常结束之后要执行的代码，即如果是break终止循环的情况，else下方缩进的代码将不执行。

Day3

列表

列表用[]定义，元素之间使用,分隔

列表定义的格式：
列表变量的名字 = [元素1, 元素2, ……]

列表定义
name_list = ['mike', 'yoyo', 'rock', 'lily']
              0       1        2       3
             -4       -3      -2       -1
             
最后一个元素取出来
print(name_list[3])
print(name_list[-1])

列表常用操作

增加	列表.append(值)	在末尾追加数据
删除	列表.remove(值)	删除第一个出现的指定数据
修改	列表[索引] = 值	修改指定索引的数据，数据不存在会报错
查询	列表[索引]	根据索引取值，索引不存在会报错
	len(列表)	列表长度(元素个数)
	值 in 列表	判断列表中是否包含某个值，结果是 True 或 False
排序	列表.sort()	升序排序

if…in 和 for…in 的区别

if…in：判断某个元素是否在列表中，如果在，if的条件为True
for…in：从头到尾 依次从 列表 中取出 每一个元素

元组

元组用()定义
tuple（元组）与列表类似，不同之处在于元组的 元素不能修改

# 列表：列表变量 = [元素1, 元素2, ……]
# 元组：元组变量 = (元素1, 元素2, ……)
my_tuple = ('mike', 'yoyo', 'lily')
#             0       1        2

# 取出第0个元素
print(my_tuple[0])  # 输出：'mike'

元组中 只包含一个元素 时，需要 在元素后面添加逗号

# 元组只有一个元素的时候，格式: (元素,)
my_tuple1 = (250,)
# 打印my_tuple1的类型
print(type(my_tuple1))

字典

字典用{}定义

 - 字典使用键值对存储数据，键值对之间使用,分隔
 - 键 key 是索引值value是数据
 - 键和值之间使用 : 分隔
 - 值可以取任何数据类型，但键只能使用字符串、数字或元组
 - 键必须是唯一的

"""
字典定义格式：
    字典变量 = {k1:v1, k2:v2,……}

取出元素的值：
    字典变量[键值]
"""
# 字典的定义
info = {'name': 'mike', 'age': 34, 'city': 'sz'}
print(info)  # {'name': 'mike', 'age': 34, 'city': 'sz'}

# 取出元素的值：字典变量[键值]
print(info['city'])

字典常用操作

增加	字典[键] = 值	键不存在，会添加键值对
删除	字典.pop(键)	删除指定键值对,返回被删除的值,如果键不存在,会报错
修改	字典[键] = 值	键存在，会修改键值对的值
查询	字典[键]	根据键取值，键值对不存在会报错
	字典.get(键)	根据键取值，键值对不存在返回None, 不会报错
遍历	for key, value in 字典.items()	遍历字典, 获取所有的键值对 (键, 值)

字符串

字符串就是一串字符，是编程语言中用来存储文本的数据类型
在 Python 中可以使用 一对双引号 " 或者 一对单引号 ’ 定义一个字符串 或者 一对三引号 ‘’’ 定义一个字符串

可以使用 索引 获取一个字符串中 指定位置的字符，索引计数从 0 开始

也可以使用 for 循环遍历 字符串中每一个字符

"""
字符串变量 = '字符串内容'
说明：可以是单引号、双引号、三引号

"""
my_str = 'python'
#         012345

# 取某个元素，和列表一样
print(my_str[0])

# 遍历取所有元素
for c in my_str:
    print(c)

f-strings 字符串格式化

python3.6后才可使用

name = 'mike'
age = 34
sex = 'male'

# 传统方式格式化
print('我叫%s, 年龄为%d, 性别为：%s' % (name, age, sex))

# 和上面打印效果一样
print(f'我叫{name}, 年龄为{age}, 性别为：{sex}')
print(F'我叫{name}, 年龄为{age}, 性别为：{sex}')

字符串的常用操作

查找	字符串.find(目标字符串, 开始索引, 结束索引)	在指定范围内, 查询目标字符串的索引, 不存在返回-1
替换	字符串.replace(原内容, 新内容, 替换次数)	返回一个替换了原内容的新字符串，可以指定替换次数
分割	字符串.split(分割符)	以分割符拆分字符串, 返回列表
拼接	字符串 + 字符串	拼接两个字符串
	字符串.join(字符串列表)	以字符串来连接字符串列表中每个元素，合并为一个新的字符串

字符串的切片

切片 使用 索引值 来限定范围，根据 步长 从原序列中 取出一部分 元素组成新序列

切片 方法适用于 字符串、列表、元组

字符串[开始索引:结束索引:步长]

注意：

 1. 指定的区间属于左闭右开型[开始索引, 结束索引)对应开始索引<= 范围<结束索引
 	从起始位开始，到结束位的前一位结束（不包含结束位本身)
 2. 从头开始，开始索引数字可以省略
 3. 到末尾结束，结束索引数字可以省略
 4. 步长：理解为走的步数，正数说明是从左往右，负数是从右往左，默认步长为+1
 5. 第一个冒号不能省略，如果未指定步长，第二个冒号可以省略

集合

集合用 {} 定义，元素之间使用 , 分隔
可通过集合对列表中的元素完成去重功能

# 集合：元素不会重复，{元素1，元素2……}
# 定义集合
my_set = {1, 2, 1, 2, 1, 2}
print(my_set)  # {1, 2}
print(type(my_set))  # <class 'set'>

# 通过集合完成对列表去重功能
name_list = ['mike', 'yoyo', 'mike']
# set(name_list)：给列表转换为set类型，即可完成去重功能
temp_set = set(name_list)
print(temp_set)  # {'mike', 'yoyo'}

list、tuple、set之间类型转换

函数	说明
list(x)	将 x 转换为列表类型
tuple(x)	将 x 转换为元组类型
set(x)	将 x 转换为集合类型

# 列表转元组、集合 类型
my_list = [1, 2, 3, 5, 3, 5]

# 列表转换为元组类型
my_tuple = tuple(my_list)
print(my_tuple)  # (1, 2, 3, 5, 3, 5)

# 列表转换为集合类型
my_set = set(my_list)
print(my_set)   # {1, 2, 3, 5}

print('============华丽分割线============')

# 元组转列表、集合 类型
my_tuple = (1, 2, 3, 5, 3, 5)

# 元组转换为列表 类型
my_list = list(my_tuple)
print(my_list)  # [1, 2, 3, 5, 3, 5]

# 元组转换为集合 类型
my_set = set(my_tuple)
print(my_set)   # {1, 2, 3, 5}

print('============华丽分割线============')

# 集合转元组、列表 类型
my_set = {1, 2, 3}

# 集合转换为列表 类型
my_list = list(my_set)
print(my_list)  # [1, 2, 3]

# 集合转换为元组 类型
my_tuple = tuple(my_set)
print(my_tuple)  # (1, 2, 3)

容器常用语法

列表

append

格式	描述
列表.append(值)	在末尾追加值

list1 = [13, 5]

# 在列表结尾追加8
list1.append(8)
print(list1)  # [13, 5, 8]

remove

格式	描述
列表.remove(值)	删除指定值的 第一个匹配项

list1 = [13, 5, 8, 5]

# 删除第一个匹配到的5
list1.remove(5)
print(list1)  # [13, 8, 5]

列表[索引] = 值

格式	描述
列表[索引] = 值	修改指定索引的值，索引不存在会报错

list1 = [13, 5]

# 修改 索引1 对应的值
list1[1] = 2
print(list1)  # [13, 2]

list1[10] = 3  # 索引不存在,程序报错

列表[索引]

格式	描述
列表[索引]	根据索引取值，索引不存在会报错

list1 = [13, 5, 8]

# 获取索引1 对应的值
print(list1[1])  # 5

print(list1[10])  # 索引不存在,程序报错

len(列表)

格式	描述
len(列表)	列表长度(元素个数)

list1 = [13, 5, 8]

# 获取列表中元素的个数
length = len(list1)
print(length)  # 3

值 in 列表

格式	描述
if 值 in 列表:	判断列表中是否包含某个值

list1 = [13, 5, 8]

# 判断列表中是否包含数据5
if 5 in list1:  # 包含数据,返回True; 不包含,返回False
    print("列表中包含该数据")  
else:  
    print("列表中不包含该数据")

# 输出:  列表中包含该数据

列表.sort()

格式	描述
列表.sort()	升序
列表.sort(reverse=True)	降序

list1 = [13, 5, 8]

# 升序排列
list1.sort()
print(list1)  # [5, 8, 13]

# 降序排列
list1.sort(reverse=True)
print(list1)  # [13, 8, 5]

字典

字典[键] = 值

格式	描述
字典[键] = 值	键不存在，会增加键值

dict1 = {"name": "张三"}

# 给字典添加键值对
dict1["age"] = 20
print(dict1)  # {"name": "张三", "age": 20}

字典.pop(键)

格式	描述
字典.pop(键)	根据键删除键值对,返回被删除的值,如果键不存在,会报错

dict1 = {"name": "张三", "age": 20}

# 删除键值对
value = dict1.pop("age")
print(dict1) # {"name": "张三"}
print(value) # 20

# 键不存在, 会报错
dict1.pop("height")

字典[键] = 值

格式	描述
字典[键] = 值	键存在，会修改键值对的值

dict1 = {"name": "张三"}

# 给字典添加键值对
dict1["name"] = "李四"
print(dict1)  # {"name": "李四"}

字典[键]

格式	描述
字典[键]	根据键取值，键值对不存在会报错

list1 = [13, 5]

dict1 = {"name": "张三"}

# 获取键值对的值
print(dict1["name"])  # "张三"

# 键不存在, 会报错
print(dict1["height"])

字典.get(键)

格式	描述
字典.get(键)	根据键取值，键值对不存在返回None, 不会报错

dict1 = {"name": "张三"}

# 获取键值对的值
print(dict1["name"])  # "张三"

# 键不存在, 返回None
print(dict1.get('height'))  # None

for key, value in 字典.items()

格式	描述
for key, value in 字典.items()	遍历字典, 获取所有的键值对 (键, 值)

dict1 = {"name": "张三", "age": 20}

# 遍历字典所有的键值对
for key, value in dict1.items():
    print(key, value)

# 输出: 
#            "name", "张三"  
#            "age", 20

字符串

字符串.find(目标字符串, 开始索引, 结束索引)

格式	描述
字符串.find(目标字符串, 开始索引, 结束索引)	在指定范围内, 查询目标字符串的索引, 不存在返回-1

str1 = "hello python"

# 查找"py"对应的索引(能找到的话, 返回"p"对应的索引)
index = str1.find("py")
print(index)  # 6

# 查找"88"对应的索引, 不存在, 返回-1
index = str1.find("88")
print(index)  # -1

字符串.replace(原内容, 新内容, 替换次数)

格式	描述
字符串.replace(原内容, 新内容, 替换次数)	返回一个替换了原内容的新字符串，可以指定替换次数

str1 = "hello python"

# 对内容进行替换, 返回新字符串
new_str = str1.replace("py", "Py")
print(new_str)  # hello Python

字符串.split(分割符)

格式	描述
字符串.split(分割符)	以分割符拆分字符串, 返回列表

str1 = "hello python hello world"

# 以空格分割字符串,每段一个元素,返回列表
str_list = str1.split(" ")
print(str_list)  # ["hello", "python", "hello", "world"]

字符串 + 字符串

格式	描述
字符串 + 字符串	拼接两个字符串

str1 = "hello"

str2 = "python"

# 拼接字符串
str3 = str1 + str2
print(str3)  # "hellopython"

字符串.join(字符串列表)

格式	描述
字符串.join(字符串列表)	以字符串来连接字符串列表中每个元素，合并为一个新的字符串

str1 = ","

name_list = ["beijing", "shenzhen", "shanghai", "guangzhou"]

# 以字符串为连接符拼接字符串列表的元素,生成新的字符串
str2 = str1.join(name_list)
print(str2)  # "beijing,shenzhen,shanghai,guangzhou"