1、注释
(1)单行注释 : #
(2)多行注释 :
'''
多行注释一般用于文档说明
类似Java中的 /**
*
*/
多行注释
多行注释
'''
或 :
"""
多行注释
多行注释
多行注释
"""
2、变量
变量的命名要求 : 字母、数字、下划线
注意 :
(1)数字不能作为开头
(2) 不能以关键字作为变量名
i = 'hello world'
print(i) # hello world
变量定义 :
定义即赋值 定义的时候不需要去指定数据的类型,Python执行器可以自动判断
# type() : 查看类型
var1 = "word"
print(var1, type(var1)) # word <class 'str'>
var1 = 1
print(var1, type(var1)) # 1 <class 'int'>
3、print函数 (只有print函数时,print前不能有空格)
print(1, 2, 3, 4) # 1 2 3 4
# sep : 可以设置分隔符
print(1, 2, 3, 4, 5, sep="|") # 1|2|3|4|5 表示以"|"分割
# end : 可以设置结束符 默认 end='\n' -- 表示换行
print("hello", end='--')
print("world") # hello--world (表示以指定字符作为结束符)
print(">>" * 50) # 表示输出50个 >> 符
4、关键字
import keyword
print(keyword.kwlist) # 输出所有的关键字 : ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally',
'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
5、5种基础数据类型
整型 : int
字符串 : str
小数 : float
布尔类型 : bool
空类型 : NoneType
注意:
(1)bool类型中的 True 和 False 是需要首字母大写
(2)变量类型可以自动去判断
(3)字符串中单引号和双引号不区分
整型
var1 = 1
print(var1) # 1
print(var1, type(var1)) # 1 <class 'int'> , 写成这样是为了方便查看变量类型
字符串 (单引号和双引号不区分)
var1 = "str1"
print(var1, type(var1)) # str1 <class 'str'>
var1 = 'str1'
print(var1, type(var1)) # str1 <class 'str'>
小数类型
var1 = 1.1
print(var1, type(var1)) # 1.1 <class 'float'>
布尔 (True 和 False 需要首字母大写)
var1 = True
var2 = False
print(var1, type(var1)) # True <class 'bool'>
print(var2, type(var2)) # False <class 'bool'>
空类型
var1 = None
print(var1, type(var1)) # None <class 'NoneType'>
6、类型之间的相互转换
(1)str转换成int
s = '1'
print(int(s), type(int(s))) # 1 <class 'int'>
print(i, type(i)) # i = int(s)
(2)str转换成float
s1 = "1.1"
print(float(s1), type(float(s1))) # 1.1 <class 'float'>
(3)float转换成int
f1 = 3.14
print(int(f1), type(int(f1))) # 3 <class 'int'>
丢失精度时 不会去做四舍五入
f1 = 3.6
print(int(f1), type(int(f1))) # 3 <class 'int'>
(4)数值类型转bool : 0 是 False ; 非0 全是True
字符串型转bool : ''是 False ; 非''全是True
b = 0
print(bool(b), type(bool(b))) # False <class 'bool'>
b = 1
print(bool(b), type(bool(b))) # True <class 'bool'>
b = -1
print(bool(b), type(bool(b))) # True <class 'bool'>
7、字符串的常见操作 ( 字符串中的索引从0开始 )
str1 = "java Python scala sql"
(1)split 切分字符串 ,生成list集合
list1 = str1.split(" ")
print(list1, type(list1)) # ['java', 'Python', 'scala', 'sql'] <class 'list'>
将list中的每一个元素拼接成一个字符串
print("-".join(list1)) # java-python-scala-sql
(2)strip 去除字符串左右两边的隐藏字符
# \t 表示一个制表符
# \n 表示换行
# \r 表示回车
str1 = " \t \n java Python scala sql \t \n \r"
str2 = str1.strip()
print(str2, type(str2)) # java Python scala sql <class 'str'>
(3)提取字符串 -- 切片
规则:[开始位置:结束位置:步长]
开始位置是从0开始,不包含结束位置,步长不写默认为1可以省略 [开始:结束)
str1 = "java Python scala sql"
# 不加步长
print(str1[5:11]) # Python
# 加步长 (开始 + 步长 < 结束 --> 取值)
print(str1[5:11:2]) # Pto (开始取索引5:P 第一次+2: 5+2<11 取索引7:t 第二次+2: 7+2<11 取索引9:o 第一次+2: 9+2=11 不取值,结束)
(4)字符串反转
str1 = "java Python scala sql"
print(str1[::-1]) # lqs alacs nohtyP avaj
需求: 只反转Python
负值取值是从后往前数 (最后一个数为 -1)
print(str1[-11:-17:-1]) # nohtyP
(5)获取字符串长度
print(len(str1)) # 21
8、格式化
a = 10
b = 3
(1)方式一 : 先定义一个模板,再通过format()方法实现
str_format = "{} * {} = {}" # 模板 其中{}相当于一个占位符
print(str_format.format(a, b, a * b)) # 通过format()方法给占位符传值,三个占位符分别传入参数 a b a*b ,结果是: 10 * 3 = 30
(2)方式二
# %d : 表示数字
# %s : 表示字符串
# %f : 表示浮点型(小数点后6位)
# %.nf : 表示输出小数点后n位
print("%d * %d = %d" % (a, b, a * b)) # 10 * 3 = 30
print("%s * %d = %d" % ('10', b, a * b)) # 10 * 3 = 30
print('%f' % 3.14) # 3.140000
print('%.1f' % 3.14) # 3.1
9、算术运算符 -- 整型、浮点类型都可以参与算术运算
# + - * / % // **
# % : 表示取余
# // : 表示整除
# ** : 表示次方
a = 10
b = 3
print(a + b) # 13
print(a - b) # 7
print(a * b) # 30
print(a / b) # 3.33333...
print(a % b) # 1
print(a // b) # 3
print(a ** b) # 1000
如果是两个 ** 号 , 则需要从后往前计算
print(2 ** 3 ** 2) # = 2^(3^2) = 2^9 = 512
如果是两个 // 号 , 则需要从前往后计算
print(10 // 3 // 2) # = 3 // 2 = 1
逻辑运算符 -- 布尔类型通常用于逻辑运算以及条件表达式(if、while)
# 与 或 非 异或
(1) 与 : & (and)
(2) 或 : | (or)
(3) 非 : not
(4) 异或 : ^ (相同为False 、 不同为True)
t = True
f = False
print(t & f) # False
print(t and f)
print(t | f) # True
print(t or f)
print(not f) # True
print(t ^ f) # True
10、Python的4大基础数据容器 -- 类似Java中的集合(Collection)
(1)列表 List -- 重复 有序 支持切片
(2)元组 tuple -- 重复 有序 不可变 支持切片
(3)集合 set -- 不重复 无序
(4)字典 dict -- 重复 有序
# 查看容器里有多少个元素 : len() 方法
>>>>>>>>>>>>> (1) 列表 list <<<<<<<<<<<<<<<<
list:
定义: 用 [] 定义一个list列表
特点:
1)可以存储不同类型的数据
2)可以存储相同数值的数据 -- 重复
3)存储数据内容是有序的 -- 有序
4)列表中的元素是可以被删除的
5)列表中可以嵌套列表
list1 = [1, 1, 2, 3, 1.1, True, "str"]
print(list1) # [1, 1, 2, 3, 1.1, True, 'str']
(1)取元素:
通过索引(index)取值,从0开始取值
print(list1[0]) # 1
(2)切片:
规则: [开始位置(包含):结束位置(不包含):步长]
取所有的值:
print(list1[::]) # [1, 1, 2, 3, 1.1, True, 'str']
print(list1[2:4:1]) # [2,3]
反序列取值:
print(list1[::-1]) # ['str', True, 1.1, 3, 2, 1, 1]
(3)修改元素:
索引下标从0开始
list1[2] = "A"
list1[3] = 'a' # str类型 "" 与 '' 效果相同
print(list1) # [1, 1, 'A', 'a', 1.1, True, 'str']
(4)删除元素:
1) pop(): 删除列表中最后一个元素
pop(index): 删除列表中指定位置的元素
list1.pop()
list1.pop(2)
2) remove(): 删除列表中给定的值,如给1删1,给'a'删'a'。如果出现重复值,删除第一个出现的值。
list1.remove('a')
print(list1) # [1, 1, 'A', 1.1, True]
(5)查找元素:
index(num)
print(list1.index(1.1)) # 3
print(list1.index(True)) # True被默认先从1开始查找,若没有则找到True为止,否则不输出值
False被默认先从0开始查找,若没有则找到False为止,否则不输出值
(6)增加元素:
1) append(): 在列表的末尾追加元素(list列表可以嵌套列表)
list1.append([1, 2])
print(list1) # [1, 1, 'A', 1.1, True, [1, 2]]
2) insert(): 在列表的指定索引位置插入元素
list1.insert(4, False)
print(list1) # [1, 1, 'A', 1.1, False, True, [1, 2]]
(7)排序:
sort()方法
list2 = [3, 4, 1, 2]
list2.sort()
print(list2[::]) # [1,2,3,4]
print(list2[::-1]) # [4,3,2,1]
(8)合并:
1) extend函数: 将另外一个列表追加到当前列表末尾 -- 改变当前list
list2 = [1, 2, 3, 4]
list3 = [6, 7, 8, 9]
list2.extend(list3) # 将 list3 追加到 list2
print(list2) # [1,2,3,4,6,7,8,9]
2) + : 将两个 list 合并成一个新的 list -- 不改变当前list
list4 = list2 + list3
print(list4) # [1, 2, 3, 4, 6, 7, 8, 9, 6, 7, 8, 9]
(9)反转:
reverse()方法
list4.reverse()
print(list4) # [9, 8, 7, 6, 9, 8, 7, 6, 4, 3, 2, 1]
等同于:
print(list4[::-1])
(10)统计: -- 若出现True, 会将其作为1统计; 若出现False, 会将其作为0统计
count()方法
list5 = [1, 1, 2, 3, 1, 0, True, False]
print(list5.count(1)) # (统计1出现的次数)3+1 = 4
print(list5.count(0)) # 2
(11)清除:
clear()方法
list5.clear()
print(list5) # []
>>>>>>>>>>>>> (2) 元组 tuple <<<<<<<<<<<<<<<<
定义 : 通过 () 定义一个元组
特点:
1)可以存储不同类型的数据
2)可以存储重复数据 -- 重复
3)元组是有序的 -- 有序
4)元组是不可变的
tuple1 = (1, 1, 2, 3, 1.1, True, "str")
print(tuple1) # (1, 1, 2, 3, 1.1, True, 'str')
(1)取元素:
通过索引(index)取值,从0开始取值
print(tuple1[4]) # 1.1
(2)改变元素 -- 不可以修改
# tuple1[3] = "A"
# print(tuple1) # 错误
(3)统计: -- True 等于 1 ; False 等于 0
count()方法
print(tuple1.count(1)) # 3
>>>>>>>>>>>>> (3) 集合 set <<<<<<<<<<<<<<<<
定义 : 使用 {} 定义一个set集合
特点:
1)set集合可以存储不同类型数据
2)set集合存储不了重复数据 -- 不重复
3)set集合是无序的 -- 无序
set1 = {1, 1, 2, "hello", False, 1.1}
print(set1) # 因为无序且不重复,所以结果不唯一
(1)取元素:
通过 for 循环取数据 ; 不能通过下标索引进行取数据,
# print(set1[2]) # 错误
for i in set1:
print( i, end=' ') # False 1 2 1.1 hello
print() # 表示换行
(2)删除数据:
1) pop(): 随机删除列表中一个元素
set1.pop()
print(set1) # 无序,删除结果不唯一
2) remove(): 删除列表中给定的值,如给1删1,给'a'删'a'。如果出现重复值,删除第一个出现的值。
set1.remove("hello")
print(set1) # 删除了'hello' ,但输出结果无序不唯一
(3)增加元素
set1.add(1) # 添加不成功 重复
set1.add(2) # 添加不成功 重复
set1.add(3) # 添加成功
print(set1)
(4)集合运算
1) & : 求两个集合的交集
2) | : 求两个集合的并集
3) - : 集合去重 ,前者减后者
set2 = {2, 3, 4}
set3 = {3, 4, 5}
print(set2 & set3) # {3,4}
print(set2 | set3) # {2,3,4,5}
print(set2 - set3) # {2}
>>>>>>>>>>>>> (4) 字典 dict <<<<<<<<<<<<<<<<
定义: 通过 {K:V} 定义一个字典
特点:
1)key是唯一的, 若出现相同的key,后面的value会覆盖前面的value
2)通过Key进行取值
3)当Key中出现 1 和 TRUE 、 0 和 False 后会出现相同key替换现象
4)Key不可变, 所以key可以是基本数据类型、元组 , 不可以是列表、集合
5)Value可以是任意类型元素, Value的值可以直接根据类型取出
6)字典可以嵌套字典
7)查询速度并不会随着元素的增多而变慢
dict = {
'x1': 55,
'x1': 66,
1: "1",
0: "0"
}
print(dict) # {'x1': 66, 1: '1', 0: '0'} Key唯一,且Value默认对应最后一个Key
(1) 获取元素:
通过Key进行取值 , 而无法通过下标index进行取值
1) 方式一:
print(dict1['x1']) # x2
print(dict1['x11']) # 不存在key,报错
2) 方式二(推荐):
get()方法
print(dict1.get("x1")) # x2
print(dict1.get('x11', '不存在')) # 默认返回 None, 也可以返回自定义的值: 不存在
(2) 删除key: pop()
dict1.pop("k1") # 删除 key 为 "k1" 的 kv
(3) 增加/修改Key对应的Value:
dict1['x11'] = 'v11' # 若字典没有key,就添加进去
dict1['x1'] = 'x3' # 若字典有key, 就修改key对应的value
print(dict1['x1']) # x3
(4)常规操作:
1) keys() : 取出所有的key (返回值是一个列表)
2) values() : 取出所有的value (返回值是一个列表)
3) items() : 取出所有的k-v (返回值是一个元组)
dict2 = {
'x1': 55,
'x1': 66
1: "1",
0: "0"
}
print(dict2)
print("所有的keys: ", dict2.keys()) # 所有keys: dict_keys(['x1', 1, 0])
print("所有的values: ", dict2.values()) # 所有values: dict_values([66, '1', '0'])
print("所有的k-v: ", dict2.items()) # 所有k-v: dict_items([('x1', 66), (1, '1'), (0, '0')])
(5)扩充字典
dict1 = {
'x1': "x1",
"x1": 'x2',
1: "1",
0: "0",
True: "true", # 1 等价于 True , 这里 1替换True
False: 'false', # 0 等价于 False , 这里 0替换False
(1, 2, 3): "tuple(1,2,3)", # 可以出现元组 , 因为字典中的Key为不可变元素 , 而元组也不可修改
# [1, 2, 3]: "list[1,2,3]", # 不可以出现列表 , 因为列表可修改
"xx1": [1, 2, 3], # value 可以为任意类型数据
"xx2": { # 这也是一种字典, 字典可以嵌套字典
"xxx1:": "vvv1",
"xxx2": {
"xxxx1": "4x1"
}
}
}
print(dict1) # {'x1': 'x2', 1: 'true', 0: 'false', (1, 2, 3): 'tuple(1,2,3)', 'xx1': [1, 2, 3], 'xx2': {'xxx1:': 'vvv1', 'xxx2': {'xxxx1': '4x1'}}}
(6)取嵌套字典值
print(dict1.get('xx2').get('xxx2').get('xxxx1')) # 4x1
11、遍历容器 (Java中的集合(Collection))
(1)列表 List -- 重复 有序
(2)元组 tuple -- 重复 有序
(3)集合 set -- 不重复 无序
(4)字典 dict -- 重复 有序
(1)遍历列表
ls1 = [3, 4, 5]
for i in ls1:
print(i)
(2)遍历元组
tup1 = (3, 4, 5)
for t in tup1:
print(t)
(3)集合Set
set4 = {4, 4, "hello", True}
for s in set4:
print(s)
(4)字典dict
dict2 = {
'xx1': "xx1",
'xx2': "xx2",
'xx3': "xx3",
}
1) keys() : 取出所有的key (返回值是一个列表)
2) values() : 取出所有的value (返回值是一个列表)
3) items() : 取出所有的k-v (返回值是一个元组)
for key in dict2.keys():
print(key)
for values in dict2.values():
print(values)
# 方式一 : kv
for kv in dict2.items():
print(kv) # 结果是('xx' , 'xx')
print(kv[0], kv[0]) # 结果是 xx xx
# 方式二 : k, v
for k, v in dict2.items():
print(k, v) # 结果是 xx xx
12、range 函数 -- for经常会和range一起使用
range 传值是一个区间: [起始,结束) 起始位置如果是0, 可以不写
(1) 输出 0~9 0 1 2 3 4 5 6 7 8 9
for i in range(10):
print(i)
(2) 步长 : 输出1~9,每隔2输出一个 1 3 5 7 9
for j in range(1, 10, 2):
print(j)
(3)需求:获取一个从1...100的列表
方式一:
list6 = []
for i in range(1, 101):
list6.append(i)
print(list6)
方式二: 列表推导式 -- for每获取到一个数就赋值给i,i立即输出到list列表。
list7 = [i for i in range(1, 101)] (等价 : i = for i in range(1, 101))
print(list7)
(4)需求:获取一个从1...100的奇数列表
方式一:列表推导式加步长
list7 = [i for i in range(1, 101, 2)]
print(list7)
方式二: 列表推导式加奇偶判断
list7 = [i for i in range(1, 101) if i % 2 == 1]
print(list7)
13、join 和 split
split自动生成一个列表
str2 = "java, python, scala,"
print(str2.split(',')) # ['java', ' python', ' scala', '']
list8 = str2.split(',')
将其变成一个字符串:
print(','.join(list8))
14、九九乘法表
print("\n".join(['\t'.join(['{} * {} = {}'.format(j, i, j * i) for j in range(1, i + 1)]) for i in range(1, 10)]))