一、概述
Python是一门由Guido van Rossum于20世纪80年代末开发的高级编程语言，并在1991年首次发布。它同JAVA一样是一门解释性语言，它的性能不如C++、golang等编译型语言，但它具有入门门槛低、开发效率高等优点。2008年发布了Python3.0的版本，我们目前所说的Python通常就是指Python3。
二、变量命名
python变量命名规则与JAVA几乎一样，以字母、数字、下划线组成，且不能以数字开头。同样的大小写敏感。但他们不同的是，python的命名是遵循下划线规则，而不是驼峰命名。
python和js一样也是一种弱语言，引用变量不需要定义类型，只是数据有类型的区分。
python中用不上的变量一般使用下划线命名，这是一个约定俗成的做法。
student_age =18;三、运算符
| 符号 | 解释 |
| + | 加号 |
| - | 减号 |
| * | 乘法 |
| // | 整除 ，结果不保留小数 |
| / | 非整除，结果保留小数 |
| ** | 求幂，2**3 表示2的三次方 |
| % | 取模，求余 |
四、内置函数
| 函数名称 | 解释 |
| print('hello','world','!!',seq=' ',end='\n') | 输出函数，输出多个对象以逗号隔开。seq指多个输出对象之间用什么间隔开来，end指print函数末尾与下一行之间用什么隔开，这两个参数都不是必输。 |
| input('请输入对象') | 输入函数 |
| type('参数') | 类型判断函数，输出参数的类型 |
| len(obj) | 长度函数，输入入参的长度 |
| range（1,5,1） | 生成连续的整数对象，1,2,3,4 不包含5 |
| max(obj) | 判断obj中的最大值 |
| ord(‘中’) | 字符串转为对应的编码 |
| chr(20013) | 编码转为对应的字符串 |
open('d:/log/致橡树.txt', 'r', encoding='utf-8') | 打开文件，返回文件对象 |
五、数据类型
基本数据类型
| 数据类型 | 描述 |
| int | 整形，如 0 |
| float | 浮点型， 如1.0 ，变量后加上 :.1f 表示保留一位小数 |
| str | 字符串，如 ”hello“ |
| bool | 布尔型，只有两个值， True 或 False |
string
# 字符串
# 字符串一般使用单引号或者双引号括起来
# 多行字符串使用三个单引号或者三个双引号括起来
# 字符串是不可变的
str1 = 'hello world'
str2 = "hello world"
print(str1) # 输出结果：hello world
print(str2) # 输出结果：hello world
# 三个单引号或者三个双引号括起来的字符串，就是多行字符串
str3 = '''
hello world
hello world
hello world
'''
print(str3) # 输出结果：hello world\nhello world\nhello world\n
# 原始字符串
# 原始字符串使用r开头，表示原始字符串，原始字符串里面的内容不会发生转义
str4 = r'hello world'
print(str4) # 输出结果：hello world
str5 = r'hello \n world'
print(str5) # 输出结果：hello \n world
# 格式化字符串
# 格式化字符串使用%s表示字符串，%d表示整数，%f表示浮点数，%o表示八进制，%x表示十六进制
name = 'John'
age = 20
print('My name is %s, and I am %d years old.' % (name, age)) # 输出结果：My name is John, and I am 20 years old.
# 格式化字符串还可以使用%(key)s表示字符串，%(key)d表示整数，%(key)f表示浮点数，%(key)o表示八进制，%(key)x表示十六进制
print('My name is %(name)s, and I am %(age)d years old.' % {'name': name, 'age': age})
# 格式化字符串还可以使用 f 开头，用花括号代替变量的方式表示
print(f'My name is {name}, and I am {age} years old.')
# 字符串的八进制写法
print('\x48\x65\x6c\x6c\x6f') # 输出结果：Hello
# 字符串的十六进制写法
print('\u4f60\u597d\u4e16\u754c') # 输出结果：你好世界
# 字符串的Unicode写法
print('\u4e16\u4e16') # 输出结果：世世
# 字符串的运算
# 重复运算
str6 = 'hello world '
print(str6 * 3) # 输出结果：hello world hello world hello world
# 成员运算
print('hello' in 'hello world') # 输出结果：True
print('hello' not in 'hello world') # 输出结果：False
# 大小比较
print('hello' > 'world') # 输出结果：False
print('hello' < 'world') # 输出结果：True
# 字符串的切片
str7 = 'hello world'
print(str7[0]) # 输出结果：h
print(str7[1]) # 输出结果：e
# 长度
print(len(str7)) # 输出结果：11
# 索引
print(str7[0:5]) # 输出结果：hello
print(str7[6:11]) # 输出结果：world
print(str7[:5]) # 输出结果：hello
print(str7[6:]) # 输出结果：world
print(str7[:]) # 输出结果：hello world
print(str7[::2]) # 输出结果：hlo ol
print(str7[::-1]) # 输出结果：dlrow olleh
print(str7[-2]) # 输出结果：r
# 遍历
for i in str7:
print(i)
# 拼接
print('hello' + ' ' + 'world') # 输出结果：hello world
print('hello' * 3) # 输出结果：hellohellohello
# 字符串常用方法
# 创建一个字符串示例
s = "hello, world! this is a test string."
# 将字符串首字母转换为大写
s_capitalized = s.capitalize()
print(s_capitalized) # 输出: Hello, world! this is a test string.
# 将每个单词的首字母转换为大写
s_titlecased = s.title()
print(s_titlecased) # 输出: Hello, World! This Is A Test String.
# 转换所有字符为大写
s_uppercase = s.upper()
print(s_uppercase) # 输出: HELLO, WORLD! THIS IS A TEST STRING.
# 转换所有字符为小写
s_lowercase = s.lower()
print(s_lowercase) # 输出: hello, world! this is a test string.
# 切片字符串
s_first_three = s[:3]
print(s_first_three) # 输出: hel
# 查找子字符串
index_hello = s.find("hello")
print(index_hello) # 输出: 0
# 查找子字符串的最后一个出现位置
last_index_world = s.rfind("world")
print(last_index_world) # 输出: 7
# 替换子字符串
s_replaced = s.replace("world", "universe")
print(s_replaced) # 输出: hello, universe! this is a test string.
# 检查字符串是否以特定前缀开头
is_start_with_hello = s.startswith("hello")
print(is_start_with_hello) # 输出: True
# 检查字符串是否以特定后缀结尾
is_end_with_string = s.endswith("string")
print(is_end_with_string) # 输出: False
# 分割字符串
words = s.split(",")
print(words) # 输出: ['hello', ' world!', ' this is a test string.']
# 合并字符串列表
rejoined = ", ".join(words)
print(rejoined) # 输出: 'hello, world!, this is a test string.'
# 删除字符串两侧的空白
s_strip = s.strip()
print(s_strip) # 输出: hello, world! this is a test string.
# 计算字符串长度
length = len(s)
print(length) # 输出: 36
# 判断字符串是否为空
is_empty = bool(s)
print(is_empty) # 输出: True
# 检查字符串是否包含另一个字符串
contains_hello = "hello" in s
print(contains_hello) # 输出: True
# 反转字符串
s_reversed = s[::-1]
print(s_reversed) # 输出: .gnirts tset a si sihT !dlrow ,olleH
# 计算字符串中字符的出现次数
count_h = s.count('h')
print(count_h) # 输出: 2
# 查找子字符串的索引
first_index_test = s.index("test")
print(first_index_test) # 输出: 24
# 使用format方法格式化字符串
formatted = "{} is {} years old".format("Alice", 30)
print(formatted) # 输出: Alice is 30 years old
# 使用f-string格式化字符串（Python 3.6+）
f_string = f"{s} has {len(s)} characters."
print(f_string) # 输出: hello, world! this is a test string. has 33 characters.
# 判断字符串是否全部是数字
is_all_digits = s.isdigit()
print(is_all_digits) # 输出: False，因为字符串中包含非数字字符
# 判断字符串是否只包含字母
is_all_letters = s.isalpha()
print(is_all_letters) # 输出: False，因为字符串中包含非字母字符
# 判断字符串是否只包含字母和数字
is_alphanumeric = s.isalnum()
print(is_alphanumeric) # 输出: False，因为字符串中包含标点符号
# 判断字符串是否只包含空格
is_whitespace = s.isspace()
print(is_whitespace) # 输出: False，因为字符串中包含非空格字符
# 判断字符串是否是ASCII字符串
is_ascii = all(ord(c) < 128 for c in s)
print(is_ascii) # 输出: False，因为字符串中可能包含非ASCII字符
# 判断字符串是否是大写字母组成的
is_all_uppercase = s.isupper()
print(is_all_uppercase) # 输出: False，因为字符串中包含小写字母
# 判断字符串是否是小写字母组成的
is_all_lowercase = s.islower()
print(is_all_lowercase) # 输出: False，因为字符串中包含大写字母
# 判断字符串是否是空字符串
is_empty_str = not s
print(is_empty_str) # 输出: False，因为字符串非空
容器类型
List
# 列表中的元素可以是任意类型
list1 = [1, 'hello', 3.14, True]
# list的创建方式有三种
# 创建方式一： 字面量语法
list1 = [1, 2, 3, 4, 5]
# 初始化一个长度为5的列表，每个元素都为0
list1 = [0] * 5 # 结果为： [0, 0, 0, 0, 0]
# 创建方式二： 构造器语法
list2 = list(range(1, 6))
# 创建方式三： 生成式语法,列表推导式，推荐用法
list3 = [i for i in range(1, 6)] # 单层循环
list4 = [print(i,j) for i in range(1, 6) for j in range(1, 6) ] # 双重循环
# 添加列表元素
# 方式一：
list1.append(6)
# 方式二：
list1.insert(0, 0)
# 列表元素替换
# 列表的索引下标可以是负数
list1[0] = 1
# 列表元素删除
list1 = [ 2, 3, 4, 5,6]
# 方式一：删除指定元素
list1.remove(2) # 指定元素删除
print(list1)
# 方式二：
list1.pop(0) # 指定下标删除，默认删除最后一个元素，返回删除的元素
print(list1)
# 方式三：
del list1[0] # 删除指定下标的元素,不返回值
# 列表的清空
list1.clear()
# 列表的排序
list1.sort() # 默认升序
list1.sort(reverse=True) # 降序
# 列表的反序
list1.reverse()
list1 = [1, 2, 3, 4, 5, 6]
# 根据元素获取元素的索引
print(list1.index(2)) # 如果没找到，则抛出异常
print(list1.index(2, 0, 3)) # 指定范围内获取索引
# 列表的切片，切片是生成了新的列表，不会改变原来的列表
print(list1[0:2]) # 获取下标为0到2的元素
print(list1[3:]) # 获取下标为3到末尾的元素
# 使用步长进行切片
list1 = [1, 2, 3, 4, 5, 6]
# 步长为2
print(list1[::2]) # [1, 3, 5]
# 步长为-1,即倒序
print(list1[::-1]) # [6, 5, 4, 3, 2, 1]
# 统计列表中元素出现的次数
list1 = [1, 2, 2, 3, 4, 5, 6]
print(list1.count(2))
# 获取列表的长度
print(len(list1))
# 列表的遍历
# 方式一：
for i in list1:
print(i)
# 方式二：
for i in range(len(list1)):
# 列表的索引下标可以是负数，负数从-1开始，-1表示最后一个元素
print(list1[i])
# 方式三： 如果同时获取索引和值，可以使用enumerate函数
for i, j in enumerate(list1):
print(i, j)
# 列表的成员运算 判断列表中是否存在某个元素
if 1 in list1:
print("1在列表中")
elif 1 not in list1:
print("1不在列表中")
# 列表的合并
list1 = [1, 2, 3]
list2 = [4, 5, 6]
# 方式一：
list1.extend(list2)
print(list1)
# 方式二：
list1 = list1 + list2
# 列表的比较
list1 = [1, 2, 3]
list2 = [1, 2, 3]
if list1 == list2:
print("两个列表相等")
elif list1 != list2:
print("两个列表不相等")
# 列表的大小比较是从一个元素的开始比较，如果第一个元素相等，则比较第二个元素，以此类推，直到找到不相等的元素为止
# 列表的元素比大小只能是相同类型的元素进行比较,不同类型的元素比较会报错
list1 = [1, 2, 3]
list2 = [2, 2, 4]
if list1 < list2:
# 预期代码会执行这里
print("list1小于list2")
elif list1 > list2:
print("list1大于list2")
元组
元组是一种不可变的容器，用法和列表一模一样，但是它的内存开销和性能都要优于列表，所以，有不可变列表的需求应当尽量使用元组。
"""
元组
元组是列表的只读版本，元组中的元素不能被修改。
元组使用圆括号而不是方括号来表示。
元组中的元素不能被修改。
元组的内存开销小于列表，因为元组不需要为每个元素分配单独的内存。
元组的性能高于列表。因为元组不需要为每个元素分配单独的内存。
元组的操作与列表一模一样。
"""
# 创建元组
t = (1, 2, 3)
print(t)
# 元组的括号可以省略
t = 1, 2, 3
print(type(t)) # <class 'tuple'>
# 一个元素的元组需要一个逗号，否则它不是元组类型，而是里面的元素类型
t = (1)
print(type(t)) # <class 'int'>
t = (1,)
print(type(t)) # <class 'tuple'>
# 元组的重复运算并不改变元组本身
t = (1, 2, 3)
print(t * 3) # (1, 2, 3, 1, 2, 3, 1, 2, 3)
print(t) # (1, 2, 3)
# 元组的索引
t = (1, 2, 3)
print(t[0]) # 1
# 元组的成员运算
t = (1, 2, 3)
print(1 in t) # True
print(4 in t) # False
print(1 not in t) # False
# 元组的切片
t = (1, 2, 3)
print(t[1:]) # (2, 3)
print(t[:2]) # (1, 2)
print(t[-1]) # 3
print(t[1::2]) # (2,) # 从1开始，步长为2
# 反向切片
t = (1, 2, 3)
# 元组的解包
t = (1, 2, 3)
a, b, c = t
print(a) # 1
print(b) # 2
print(c) # 3
# 将后面的元素合并到c中
t = (1, 2, 3, 4, 5)
a, b, *c = t
print(a) # 1
print(b) # 2
print(c) # [3, 4, 5]
print(type(c)) # <class 'list'>
# 将中间的元素合并到b中
t = (1, 2, 3, 4, 5)
a, *b, c = t
print(a) # 1
print(b) # [2, 3, 4]
print(c) # 5
print(type(c)) # <class 'int'>
# 注意，两/三个元素换值并不是用的元组的解包，而是在底层做了一些优化，
a = 1
b = 2
c = 3
d = 4
a, b = b, a # 这里用到的指令叫ROT_TWO
# 三个元素换值
a, b, c = c, a, b # 这里用到的指令叫ROT_THREE
# 四个元素换值用的才是解包，没有一个指令叫ROT_FOUR
a, b, c, d = d, a, b, c
# 元组的合并运算
t1 = (1, 2, 3)
t2 = (4, 5, 6)
print(t1 + t2) # (1, 2, 3, 4, 5, 6)
print(t1 * 3) # (1, 2, 3, 1, 2, 3, 1, 2, 3)
set
# 集合
# 集合是Python中一个重要的数据类型，它类似于数学中的集合，集合中的元素是唯一的，并且没有顺序。
# 集合中的元素可以是任何类型，包括数字、字符串、元组、列表等。
# 集合是无序的，所以不能通过索引访问元素，但是可以通过循环遍历集合中的元素。
# 集合的成员运算性能是高于列表的。
# 集合底层是哈希表，所以查找、插入和删除的时间复杂度都是O(1)。
# 集合的创建可以使用set()函数，也可以使用{}符号创建。
set1 = {1, 2, 3, 4, 5}
set2 = set([1, 2, 3, 4, 5])
set3 = set((1, 2, 3, 4, 5))
set4 = set({'a': 1, 'b': 2, 'c': 3})
set5 = set('abcde') # 创建一个包含a、b、c、d、e的集合
set6 = set(range(5)) # 创建一个从0到4的集合
set7 = set(range(5), range(5, 10)) # 创建一个从0到9的集合
# 集合的运算
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1.union(set2) # 合并两个集合，并返回一个新的集合
set4 = set1.intersection(set2) # 求两个集合的交集，并返回一个新的集合
set5 = set1.difference(set2) # 求两个集合的差集，并返回一个新的集合
set6 = set1.symmetric_difference(set2) # 求两个集合的异或集，并返回一个新的集合
set7 = set1.copy() # 返回一个集合的浅拷贝
set8 = set1.update(set2) # 将set2中的元素添加到set1中
set9 = set1.intersection_update(set2) # 将set1和set2的交集更新到set1中
set10 = set1.difference_update(set2) # 将set1和set2的差集更新到set1中
set11 = set1.symmetric_difference_update(set2) # 将set1和set2的异或集更新到set1中
set12 = set1.add(6) # 将6添加到set1中
set13 = set1.remove(6) # 将6从set1中移除
set14 = set1.discard(6) # 将6从set1中移除，如果set1中不存在6，则不会报错
# 集合的比较
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1.isdisjoint(set2) # 判断两个集合是否没有交集，返回布尔值
set4 = set1.issubset(set2) # 判断set1是否是set2的子集，返回布尔值
set5 = set1.issuperset(set2) # 判断set1是否是set2的父集，返回布尔值
# 集合的迭代
set1 = {1, 2, 3, 4, 5}
for i in set1:
print(i)
# 集合的排序
set1 = {1, 2, 3, 4, 5}
set2 = sorted(set1)
set3 = sorted(set1, reverse=True)
set4 = sorted(set1, key=lambda x: x % 2)
set5 = sorted(set1, key=lambda x: x % 2, reverse=True)
# 集合的清除
set1 = {1, 2, 3, 4, 5}
set1.clear()
set1 = {1, 2, 3, 4, 5}
set2 = set1.pop() # 随机移除一个元素并返回
dict
# 字典
# 字典是一种无序的集合，其中每个元素有一个与元素关联的键。
# 键必须唯一，但值不需要。
# 字典的键使用的也是hash结构，所以性能比较高。键必须不可变，但值可以任意。
# 字典其实是一个 json 结构， 如：{"name": "zhangsan", "age": 18}
# 字典的创建
# 方式一：
dict1 = {"name": "zhangsan", "age": 18}
# 方式二：
dict2 = dict(name="zhangsan", age=18)
# 方式三： 推导式语法
dict3 = {i: i * i for i in range(1, 11)}
# 生成器，注意，这不是元组
gen_obj = (i * i for i in range(1, 11))
print(gen_obj)
print(next(gen_obj))
print(next(gen_obj))
# 访问字典中的元素
print(dict1["name"]) # zhangsan 如果键不存在，会报错
# 如果键不存在，返回默认值
print(dict1.get("name1", "zhangsan")) # zhangsan
# 如果键不存在，返回None
print(dict1.get("name1")) # zhangsan 如果键不存在，返回None
# 删除字典中的元素
dict1.pop("name") # 删除键为name的元素，并返回被删除的元素，如果键不存在，会报错
# 遍历字典
# 同时遍历键和值
for key, value in dict1.items():
print(key, value)
# 遍历键
for key in dict1:
print(key) # age
# 遍历键
for key in dict1.keys():
print(key)
# 遍历值
for value in dict1.values():
print(value)
# 字典元素的添加和修改
dict1["name"] = "lisi"
dict1["age"] = 20
dict1.setdefault("name", "lisi2") # 如果键不存在，添加键值对，如果键存在，则不更新，value可以不写，默认为None
print(dict1) # {'name': 'lisi', 'age': 20}
# 成员运算
print("name" in dict1)
print("name1" in dict1)
print("name" not in dict1)
# 合并
dict1.update(dict2) # 将dict2合并到dict1中 ，如果键存在，则以dict2的值覆盖dict1的值
# zip函数
# zip函数可以将多个迭代对象合并成一个迭代对象，迭代对象中的元素必须一一对应
list1 = [1, 2, 3]
list2 = ["a", "b", "c"]
print(dict(zip(list1, list2))) # {1: 'a', 2: 'b', 3: 'c'}
print(list(zip(list1, list2))) # [(1, 'a'), (2, 'b'), (3, 'c')]
备注：Python钟变量的数据类型是可以相互转换的，这点与JAVA不同。
六、类型转换
# 字符串转浮点型
str_demo = 1.222;
print(float(str_demo))
# 字符串转整型
str_demo = "1";
print(int(str_demo))
# 字符串转布尔型
str_demo = "1";
print(bool(str_demo))
# 浮点型转字符串
str_demo = 1.222;
print(str(str_demo))
# 字符串转列表
str_demo = "1,2,3,4,5";
print(str_demo.split(","))
# 字符串转元组
str_demo = "1,2,3,4,5";
print(tuple(str_demo.split(",")))
# 字符串转字典，即 key-value
str_demo = "1,2,3,4,5";
print(dict(zip(range(len(str_demo.split(","))), str_demo.split(","))))
七、注释
单行注释：
# 这是一行单行注释多行注释：
"""
这里是多行注释，用三个双引号表示
这里是多行注释，用三个双引号表示、
这里是多行注释，用三个双引号表示
"""八、格式输出
# 十进制
a= 15
print(a)
# 二进制
a= 0b1111
print(a)
# 八进制
a= 0o17
print(a)
# 十六进制
a= 0xf
print(a)
# 十进制转 二进制
print(bin(15))
# 十进制转 八进制
print(oct(15))
# 十进制转 十六进制
print(hex(15))
a= float(122.222)
b= float(45)
# 保留一位小数 %.1f
print('%.1f + %f = %f' % (a, b, a+b))
print('%f - %f = %f' % (a, b, a-b))
print('%f * %f = %f' % (a, b, a*b))
print('%f / %f = %f' % (a, b, a/b))
# 打印分割线
print('-' * 30)
# f --> format， 花括号里面表示变量，:.1f表示将浮点型数值保留1位小数
print(f'{a} + {b} = {a+b}')
print(f'{a} - {b} = {a-b}')
print(f'{a} * {b} = {a*b}')
print(f'{a} / {b} = {a/b:.1f}')
print(f'{a} % {b} = {a%b}')九、分支结构
Python中以4个空格的缩进代表方法体，方法体内的变量是可以在方法体外取到的，这跟JAVA完全不同。不推荐方法体外使用方法体内定义的变量。
if 分支
# 如果今天出晴天就去游泳，如果今天阴天就去钓鱼，其他情况就待在家里
weather = '阴天'
if weather == '晴天':
print('去游泳')
elif weather == '阴天':
print('去钓鱼')
elif weather == '下雪':
# 当暂时不知道做什么时 可使用 pass 关键字让程序先通过检查
pass;
else:
print('待在家里')
# if 的三元表达式
weather = '下雪'
if weather == '晴天':
print('去游泳')
else:
print('待在家里')
# 使用三元表达式，它的语法是：表达式1 if 条件表达式 else 表达式2
weather = '下雪'
print('去游泳' if weather == '晴天' else '待在家里')for 循环
# for循环打印 100次 hello world i值从 0 - 99
for i in range(100):
print(i,'hello world')
# 下面这句只会打印一次，i 值也可以取到 i= 99
print(i,'hello world')
# range函数使用示例 ，从100循环到10000（不包含10000），步长为2，打印 i值
for i in range(100,10000,2):
print(i)
# 对于一个用不到的循环次数变量，python一般使用 下划线 _ 来表示
for _ in range(100):
print('hello world')
# forearch循环 同时获取下标
nums = [1,2,3,4,5]
for num, i in enumerate(nums):
print(i, num);while 循环
# 把上述代码改为 while循环打印 100次 hello world
i = 0
while i < 100:
print(i,'hello world')
i += 1备注： Python中没有 do ..while 循环。
扫一扫
1028
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
