基本语句
输入
input()
eg:
输出
print(内容)
注释
单行注释:
# 注释内容
多行注释:""" 注释内容 """
数据类型:
字面量: 整型、浮点数、字符串......int float string
查看数据类型:
type(数据) 查看数据类型
转换函数
- int(x):将x转换成整数类型
- float(x):将x转换成浮点数类型
- str(x):将x转换成字符串类型
标识符格式
标识符:英文、中文、数字、下划线
1.大小写敏感
2.不可使用关键词
3.内容限定
4.不能以数字开头
算数运算符
算术运算符: + - * / // % **
- // 取整除:返回商的整数部分d eg:m % n = d ...... p
- ** 指数:a**b为a的b次方
复合赋值运算符
复合赋值运算符: += -= *= /= %= **= //=
选择判断语句
布尔类型和比较运算符
布尔类型:bool(true 或者 false)
比较运算符: == != > < >= <=
if语句
if (条件):
条件成立,所执行的事情
if-else语句
if 条件 :
条件成立, 执行的语句
else :
不满足条件时, 执行的语句
if-elif-else语句
if 条件1 :
条件1成立执行的语句
elif 条件2 :
条件2成立执行的语句
elif 条件3 :
条件3成立执行的语句
...
else :
所有条件都不成立执行的语句
字符串
- 单引号定义法
- 双引号定义法
- 三引号定义法
字符串嵌套: 双引号可以内含单引号 单引号可以内含双引号
转义字符:/ => 可以取消特定符号的效果, 可以使其变成普通字符
print(' 单引号定义法 ') print(" 双引号定义法 ") print(""" 三引号定义法 """) print(" 双引号 '内含单引号' ") print(' 单引号 "内含双引号" ') print(" 字符串 /' 使用转义字符使单引号变成普通字符 /' ")
字符串的拼接
方法1: str = str1 + str2 : 必须是字符串类型的拼接
方法2(占位法): str = str1 % (x)
占位符:
- %s : 将内容转换为字符串
- %d : 将内容转换成整数
- %f : 将内容转换成浮点数、
- str1中含有占位符
- % 表示我要占位
- s 表示将 x 这个变量变成占位符的类型放入到占位的地方 (即%s的位置)
- x 这个变量的类型可以是字符串、整数、浮点数, 但都会转换成占位符的类型放入到占位的地方
str1 = 'Hello '
str2 = "World!"
str3 = """Hello %s"""
num = 921
f = 9.21
str = str1 + str2
print("str1 + str2 = ", str1 + str2)
print("str3 % str2 = ", str3 % str2)
print("str3 % num = ", str3 % num)
print("str3 % f = ", str3 % f)
name = 'wjk'
age = 25
birthday = 9.21
print("我的姓名是:%s 我的年龄是 %d 我的生日是 %.2f" % (name, age, birthday))
格式化
- 精度控制 : m.n => m控制宽度,用空格补足 n控制小数点精度
- 快速格式化 : f"内容{变量}" => 不关心类型,不关心精度控制
print("%5.2f" % 921.921)
print(f"我的姓名是: {name} 我的年龄是 {age} 我的生日是 {birthday}")
# 表达式格式化演示
print("1 * 2 = %d" % (1 * 2))
print(f"1 * 2 = {1*2}")
print("name的type为%s" % type(name))
循环
while 语句
while 条件 :
条件满足执行语句
九九乘法表:
i = 1;
while i <= 9 :
j = 1
while (j <= i) :
print(f"{j}*{i}={i * j} ", end='')
j += 1
print("")
i += 1
for 语句
基础语句 :
for 临时变量 in 待处理数据集 :
循环条件满足时执行的语句
待处理数据集 => 序列类型:字符串、列表、元组......
range 语句 :
1. range(num)
获取一个从0开始, 到num结束的数字序列
eg: range(5):[0, 1, 2, 3, 4]2. range(num1, num2)
获取一个从num1开始, 到num2结束的数字序列
eg: range(2, 5): [2, 3, 4]3.range(num1, num2, step)
获得一个从num1开始, 到num2结束的数字序列, step为数字之间的步长
eg: range(5, 10, 2) : [5, 7, 9]
for i in range(5) :
print(i)
for i in range(1, 10, 2) :
print(i)
函数
函数的定义
def 函数名(传入参数) :
函数体
return 返回值
当全局变量想在函数内使用时,需要在函数体内部对全局变量进行声明
global 关键字声明a是全局变量
数学函数
函数 | 说明 |
---|---|
abs() | 取整数绝对值 |
fabs() | 取浮点数绝对值 |
cmp(x, y) | x > y : 返回 1 x == y : 返回 0 x < y : 返回 -1 |
exp(x) | e的x次方 |
floor(x) | x向下取整 |
max() | 最大值 |
min() | 最小值 |
pow(x, y) | x的y次方 |
sqrt(x) | x开平方 |
转义字符
转义字符 | 说明 |
---|---|
\ | 在行尾时,是续行符 |
\\ | 反斜杠 |
\' | 单引号 |
\" | 双引号 |
\a | 响铃 |
\b | 退格 |
\e | 转义 |
\000 | 空 |
\n | 换行 |
\v | 纵向制表符 |
\t | 横向制表符 |
\r | 回车 |
\f | 换页 |
\o | 八进制数 |
\x | 十六进制数 |
break语句
终止循环语句
continue语句
跳出本次循环
数据容器
数据容器的定义
一种可以容纳多份数据的数据类型
数据容器的划分依据
- 是否支持重复元素
- 是否可以修改
- 是否有序
数据容器的分类
- 列表 list
- 元组 tuple
- 字符串 str
- 集合 set
- 字典 dict
列表
语法 | 功能 |
---|---|
列表.index(元素) | 查找指定元素在列表的下标, 如果找不到, 报错ValueError |
列表[下标] = 值 | 修改特定位置(索引)的元素值 |
列表.insert(下标, 元素) | 在特定下标插入元素 当前下标之后的元素向后移动一位 |
列表.append(元素) | 将指定元素追加到列表的尾部 |
列表.extend(元素) | 将数据容器的内容依次取出, 追加到列表尾部 |
1. del 列表[下标] | 删除指定下标的元素 |
列表.remove(元素) | 删除某元素在列表中的第一个匹配项 |
列表.clear() | 清空列表修改元素 |
列表.count(元素) | 统计元素个数 |
len(列表) | 统计列表内, 有多少元素 |
# 查询操作
mylist = ["wjk", "xkbb", "karry"]
idx = mylist.index("karry")
print(f"idx = {idx}")
# 修改操作
mylist[2] = "Karry Wang"
print(f"修改操作之后的值为{mylist}")
# 插入操作
mylist.insert(1, "happy")
print(f"插入操作之后的值为{mylist}")
# 追加操作
mylist.append("hahaha")
print(f"追加操作之后的值为{mylist}")
# 删除操作
del mylist[mylist.index("hahaha")]
print(f"删除操作之后的值为{mylist}")
e = mylist.pop(1)
print(f"删除的元素为{e}")
mylist.remove("xkbb")
print(f"删除操作之后的值为{mylist}")
# 清空列表
mylist.clear()
print(f"清空操作之后的值为{mylist}")
# 统计操作
print(f"统计操作的值为{mylist.count(1)}")
# 列表查询
print(f"查询操作的值为{len(mylist)}")
元组
语法 | 功能 |
---|---|
1. 元组 = (元素1, 元素2, 元素3, 元素4......) 2. 元组 = 元素1, 元素2, 元素3,...... | 定义元组,元组内元素的数据类型可以不同 |
元组 = () | 定义空元组 |
元组[] 元组[][] | 访问元组内的值 |
元组[bg : ed] (截取【元组[bg], 元组[ed]】) | 截取元组内的一段 |
元组1 + 元组2 | 元组的连接组合 |
del 元组 | 删除整个元组(元组中的元组值是不允许删除的) |
len(元组) | 计算元素个数 |
元组 * 复制数量 | 复制元组 |
元素 in 元组 | 判断元素是否存在 |
cmp(元组1, 元组2) | 比较两个元组元素 |
max(元素) | 返回元组中元素最大值 |
min(元素) | 返回元组中元素最小值 |
tuple(列表) | 将列表转换为元组 |
tup1 = ("happy", 123, 13.14)
tup2 = "a", 1, 2, 13.14, tup1
print(f"访问元组元素为{tup2[4][0]}")
print(f"计算元组元素为{len(tup1)}")
print(f"复制元组为{tup1 * 3}")
print(f"判断元素是否存在{123 in tup1}")
字符串
操作符 | 说明 |
---|---|
+ | 字符串连接 |
* | 重复输出字符串 |
[] | 通过索引获取字符串中的字符 |
[ : ] | 截取字符串 |
in | 成员运算符(如果字符串中包含给定字符返回True) |
not in | 成员运算符(如果字符串中不包含给定字符返回True) |
r / R | 原始字符串 : 所有的字符串都是直接按照字面的意思来使用,没有转义特殊或不能打印的字符 |
% | 格式字符串 |
字典
语法 | 说明 |
---|---|
字典 = {key1 : value1, key2 : value2} | 定义字典 |
字典[key] | 访问字典里面的值 |
字典.clear() | 清空字典 |
del 字典 | 删除字典 |
del 字典[key] | 删除字典元素 |
cmp(dict1, dict2) | 比较 |
len(字典) | 计算长度 |
str(字典) | 输出字典可打印的字符串表示 |
字典[key] = value | 修改字典里面的值 |
字典.copy() | 返回一个字典的浅复制 |
dict.update(dict2) | 把字典2里面的值更新到dict里面 |
dict1 = {"001" : 1, "002" : 2, "003" : 3}
print(dict1["001"])
dict2 = {}
dict2.update(dict1)
for i in dict2 :
print(dict2[i])