本文详细介绍了Python的基础语法，包括输出函数print的使用、变量类型如整数、浮点数、布尔值和字符串的定义及转换，以及运算符、流程控制结构如if-else、循环等。此外，还探讨了列表、字典、元组和集合等数据结构的创建、操作及特性，以及字符串的处理方法，如切片、格式化输出。文章最后涉及了函数的定义和调用，以及变量的作用域概念。
输出函数：print
可以输出数字、字符串、含有运算符的表达式
数字：print(1) print(2)
字符串：print("hello world") print('hello')
含有运算符的表达式：print(1+3) 输出的是4 print("1+3") 输出的是1+3
可以将内容输出到显示器、文件
print(1) 将1输出到显示器中
fp=open("F:/text.txt","a+") #a+：如果文件不存在就创建，存在就在文件内容的后面继续追加
print("helloworld",file=fp) #把helloworld输出到文件中
fp.close()
输出形式可以是换行、不换行
print("hello","world","python") #这三个单词将在一行输出
转义字符
反斜杠加上想要实现转移的字母
- 当字符串中包含反斜杠、单引号和双引号等有特殊用途的字符时，必须使用反斜杠对这些字符进行转移
- 当字符串中包含换行、回车等无法直接表示的特殊字符时，也可使用转义字符（换行：\n Tab：\t）
原字符：不希望字符串中的转义字符起作用，就使用原字符，即在字符串前加r、R
print(r"hello\nworld") 输出hello\nworld 注意：最后一个字符不能是反斜线
python中的标识符和保留字
标识符
变量、函数、类、模块和其他对象起的名字就叫做标识符
- 以字母、数字、下划线组成
- 不能以数字开头
- 不能是保留字
- 严格区分大小写
保留字
有一些单词被赋予了特定的意义，这些单子在给任意对象起名字是都不能用
变量
变量由三部分组成
- 标识：标识对象存储的内存地址，使用内置函数id(obj来获取)
- 类型：标识对象的数据类型，使用内置函数type(obj)来获取
- 值：标识对象存储的具体数据，使用print(obj)可以将值输出
在多次赋值之后，变量会指向新的空间
数据类型
整数类型(int)
可以表示正数、负数、零
整数的各种进制表示
- 十进制： 默认
- 二进制： 以0b开头
- 八进制： 以0o开头
- 十六进制： 以0x开头
浮点数类型(float)
布尔类型(bool)
字符串类型(str)
三引号里的字符串会根据输入的格式输出（""“str1"”" ， ‘’‘str2’’’）
str3="""hello
world"""
输出是：hello
world
类型转换
转换为整型：int()
将str转成int类型，字符串必须为数字串（整数）
将float转成int类型，截取整数部分，舍掉小数部分
转化为字符型：str()
转换为浮点型：float()
整数类型转换为浮点型是后面加 .0
布尔类型转换为浮点型是 true变成1.0 false变成0.0
字符串中的数据如果是非数字串则不允许转换
注释
单行注释#
多行注释 ‘’’ 或 “”"
中文编码声明 #coding:utf-8
input()函数
用来接收用户的输入，类型为str
运算符
算术运算符
标准算数运算符
- 加 +
- 减 -
- 乘 *
- 除 /
- 整除 // （一正一负向下取整）
取余运算符
% (一正一负用公式：余数=被除数-除数*商)
幂运算符
**
赋值运算符
执行顺序：从右到左
支持链式赋值：a=b=c=1 （存储地址相同）
支持参数赋值： += -= *=
支持系列解包赋值：a,b,c=1,2,3 （a,b=b,a交换值）
比较运算符
<,>,<=,>=,!=
== 比较对象的值
is,is not 比较对象的id
布尔运算符
布尔值之间的运算（and/or/not/in/not in）
and：两者都为true则为true
or：两者有一个为true则为true
not：对布尔值取反
in：判断一个字符串是否在另一个字符串中
not in：判断一个字符串是否不再另一个字符串中
位运算符
将数据转成二进制进行计算
位与（&）
对应位数都是1，结果才为1，否则为0
位或（|）
对应位数都是0，结果才为0，否则为1
左移位运算符（<<）
高位溢出舍弃，低位补0（相当于乘2）
右移位运算符（>>）
低位溢出舍弃，高位补0（相当于除以2）
运算符的优先级
算数运算符>位运算符>比较运算符>布尔运算符
- **
- *,/,//,%
- +,-
- <<,>>
- &
- |
- ,<,>=,<=,==,!=
- and
- or
- =
流程控制
顺序结构
程序从头到尾按顺序执行，中间没有判断和跳转
选择结构
python一切皆对象，所有对象都有一个布尔值，可以使用内置函数bool()获取对象的布尔值
（False、数值0、None、空字符串、空列表、空元组、空字典、空集合）的布尔值是False，其他对象的布尔值均为True
单分支结构
if 条件表达式:
条件执行体
money=100
i=int(input("请输入取款金额"))
if i<money:
money=money-i
print("余额",money)
双分支结构
if 条件表达式:
条件执行体1
else:
条件执行体2
money=100
i=int(input("请输入取款金额"))
if i<money:
money=money-i
print("余额",money)
else:
print("余额不足")
多分支结构
if 条件表达式1:
条件执行体1
elif 条件表达式2:
条件执行体2
elif 条件表达式N:
条件执行体N
[else:]
条件执行体N+1
i=int(input("请输入成绩："))
if i>=90 and i<=100:
print("您的等级是A")
elif i>=80 and i<90:
print("您的等级是B")
elif i>=70 and i<80:
print("您的等级是C")
elif i>=60 and i<70:
print("你的等级是D")
elif i>=0 and i<60:
print("您的等级是E")
else:
print("您的成绩有误")
嵌套if
if 条件表达式1:
if 内层条件表达式:
内层条件执行体1
else:
内层条件执行体2
else:
条件执行体
条件表达式
x if 判断条件 else y
如果判断条件为true，条件表达式返回x，否则返回y
print(5 if 5<=7 else 7) #输出5
循环结构
range()函数的使用
range()用于生成一个整数序列（所有range对象占用内存空间是相同的）（in和not in可以判断序列中是否存在指定整数）
可以使用list()函数把数字都列出来
- range(x)：创建一个(0,x)之间的整数序列，步长为1（不包含x）
- range(x,y)：创建一个(x,y)之间的整数序列，步长为1（不包含x）
- range(x,y,z)：创建一个(x,y)之间的整数序列，步长为z
x=range(10)
print(x) #输出range(0, 10)
print(list(x)) #输出[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
x=range(5,13)
print(x) #输出range(5, 13)
print(list(x)) #输出[5, 6, 7, 8, 9, 10, 11, 12]
x=range(1,13,3)
print(x) #输出range(1, 13, 3)
print(list(x)) #输出[1, 4, 7, 10]
while循环
while 条件表达式:
条件执行体
a=1
while a<=5:
print(a)
a+=1 #输出12345
for-in循环
for-in循环的对象必须是可迭代对象（字符串和序列）
for 自定义的变量 in 可迭代对象:
循环体
sum=0
for i in range(1,101):
sum=sum+i
print(sum) #输出1到100的整数和
循环体内不需要访问自定义变量，可以将自定义变量替换为下划线
break、continue与else语句
break语句（只影响本层循环）
用于结束循环结构，可以和if一起使用
for … in …:
…
if …:
break
for item in range(3):
i = int(input("请输入密码："))
if i==8888:
print("密码正确")
break
else:
print("密码错误")
while …:
…
if …:
break
a=0
while a<3:
i=int(input("请输入密码："))
if i==8888:
print("密码正确")
break
else:
print("密码错误")
a+=1
continue语句（只影响本层循环）
用于结束当前循环，进入下一循环，可以和if一起使用
for … in …:
…
if …:
continue
…
for item in range(1,100):
if item % 10 == 0:
continue
print(item)
while …:
…
if …:
continue
…
else语句
else和if搭配：if条件表达式不成立时执行else
else和while、for搭配：没有遇到break时，执行else
嵌套循环
循环结构中嵌套了另一个循环，内层循环作为一个外层循环的执行体
列表
- 列表可以储存N个元素，程序也可以对这些元素进行整体操作，列表内储存的是元素的id值
- 列表可以存储重复数据
- 列表可以任意类型的数据混合存储
- 列表按顺序有序排列
列表的创建与删除
列表的创建
使用[ ]创建：a=[‘hello’,‘world’]
使用内置函数list()创建：a=list([‘hello’,‘world’])
列表的删除
列表的查询操作
获取列表中指定元素的索引
使用index()：
列表中存在多个相同的元素，只返回相同元素中的第一个元素的索引
若查询的元素的索引不存在，则会显示ValueError
可以再指定的start和stop中查找
获取列表中的单个元素
正向索引从0到N-1
反向索引从-N到-1
若所查找的索引不存在，则显示IndexErrot
获取列表中的多个元素
列表名[start:stop:step]
列表元素的增、删、该操作
列表元素的增加
append()：在列表的末尾添加一个元素
lst=[1,2,3,4,5,6,7]
lst.append(9)
print(lst) #输出[1, 2, 3, 4, 5, 6, 7, 9]
lst=[1,2,3,4,5,6,7]
lst2=[9,10]
lst.append(lst2)
print(lst) #输出[1, 2, 3, 4, 5, 6, 7, [9,10]]
extend()：在列表的末尾至少添加一个元素
lst=[1,2,3,4,5,6,7]
lst2=[9,10]
lst.extend(lst2)
print(lst) #输出[1, 2, 3, 4, 5, 6, 7, 9, 10]
insert()：在列表的任意位置添加一个元素
lst=[1,2,3,4,5,6,7]
lst.insert(1,6)
print(lst) #输出[1, 6, 2, 3, 4, 5, 6, 7]
lst=[1,2,3,4,5,6,7]
lst2=[9,10]
lst.insert(1,lst2)
print(lst) #输出[1, [9, 10], 2, 3, 4, 5, 6, 7]
切片：在列表的任意位置添加至少一个元素
lst=[1,2,3,4,5,6,7]
lst1=[10]
lst[2:5:1]=lst1
print(lst) #输出[1, 2, 10, 6, 7]
列表元素的删除
remove()
- 一次删除一个元素
- 重复元素只删除第一个
- 元素不存在时输出ValueError
lst=[1,2,3,4,5,6,7,1]
lst.remove(1)
print(lst) #输出[2, 3, 4, 5, 6, 7, 1]
pop()
- 删除第一个指定索引上的元素
- 指定索引不存在输出IndexError
- 不指定索引，删除列表中的最后一个元素
lst=[1,2,3,4,5,6,7,1]
lst.pop(1)
print(lst) #输出[1, 3, 4, 5, 6, 7, 1]
切片
一次至少删除一个元素
lst=[1,2,3,4,5,6,7,1]
lst[1:3]=[]
print(lst) #输出[1, 4, 5, 6, 7, 1]
clear()
清空列表
del
删除列表
列表元素的修改
为指定索引的元素赋予新值
lst=[1,2,3,4,5,6,7,1]
lst[3]=9
print(lst) #输出[1, 2, 3, 9, 5, 6, 7, 1]
为指定切片赋予新值
lst=[1,2,3,4,5,6,7,1]
lst[1:3]=[10,10,10,10,10]
print(lst) #输出[1, 10, 10, 10, 10, 10, 4, 5, 6, 7, 1]
列表元素的排列
使用sort()对列表进行排序默认是升序，可以指定reverse=True进行降序排序
lst=[1,2,3,4,5,6,7,1]
lst.sort()
print(lst) #输出[1, 1, 2, 3, 4, 5, 6, 7]
lst.sort(reverse=True)
print(lst) #输出[7, 6, 5, 4, 3, 2, 1, 1]
使用内置函数sroted()生成一个新的列表，可以指定reverse=True进行降序排序
lst=[1,2,3,4,5,6,7,1]
new_lst=sorted(lst)
print(new_lst) #输出[1, 1, 2, 3, 4, 5, 6, 7]
列表生成式
[表示列表元素的表达式 for 自定义变量 in 可迭代对象]
lst=[i*2 for i in range(1,10)]
print(lst) #输出[2, 4, 6, 8, 10, 12, 14, 16, 18]
字典
字典是python中内置的数据结构之一，是一个可变序列
字典以键值对的方式存储数据，是一个无序序列
键不可变（str）
通过hash函数计算存储位置找到值
键key不允许重复，值value可以重复
字典的创建和删除
字典的创建
使用花括号：scores={‘张三’:1,‘李四’:2,‘王五’:3}
scores={'张三':1,'李四':2,'王五':3}
print(scores) #输出{'张三': 1, '李四': 2, '王五': 3}
使用内置函数dict()：dict()
print(dict(name='张三',age=25)) #输出{'name': '张三', 'age': 25}
字典的删除
字典的查询操作
[]：如果字典中不存在指定的key，则显示keyError
scores={'张三':1,'李四':2,'王五':3}
print(scores['张三']) #输出1
get()：如果字典中不存在指定的key，则显示一个可以修改的默认参数
scores={'张三':1,'李四':2,'王五':3}
print(scores.get('张三')) #输出1
sorses={'张三':1,'李四':2,'王五':3}
print(sorses.get('张四','不存在')) #输出不存在
字典的增、删、改操作
字典的增加
sorses={'张三':1,'李四':2,'王五':3}
sorses['小明']=4
print(sorses) #输出{'张三': 1, '李四': 2, '王五': 3, '小明': 4}
字典的删除
使用del删除指定键
sorses={'张三':1,'李四':2,'王五':3}
print(sorses.get('张四','不存在')) #输出{'李四': 2, '王五': 3}
clear()
清空字典的元素
字典的修改
sorses={'张三':1,'李四':2,'王五':3}
sorses['张三']=4
print(sorses) #输出{'张三': 4, '李四': 2, '王五': 3}
字典的视图获取
keys()：获取字典中所有key
values()：获取字典中所有的value
items()：获取字典中所有的key、value
字典生成式
{表示字典key的表达式:表示字典value的表达式 for 自定义表示key的变量,自定义表示value的变量 in 可迭代对象}
a=['张三','李四','王五']
b=[1,2,3]
c={a:b for a,b in zip(a,b)}
print(c) #输出{'张三': 1, '李四': 2, '王五': 3}
内置函数zip()
a=['张三','李四','王五']
b=[1,2,3]
print(list(zip(a,b))) #输出[('张三', 1), ('李四', 2), ('王五', 3)]
元组
字典是python中内置的数据结构之一，是一个不可变序列，无法进行增、删、改操作
元组的创建
()：a=(‘hello’,‘world’,1)
内置函数tuple()：t=tuple((‘hello’,‘world’,1))
只包含一个元素需要使用逗号和小括号：a=(1,)
集合
和字典类似，不能重复
集合的创建方式
s={}
使用内置函数set()，定义空集合：set()
print(set([1,2,3,4])) #输出{1, 2, 3, 4}
print(set((1,2,3,4))) #输出{1, 2, 3, 4}
print(set('hello')) #输出{'l', 'e', 'h', 'o'}
print(set({1,2,3,4})) #输出{1, 2, 3, 4}
集合的相关操作
集合元素的判断
in、not in
集合元素的增加
add()：一次添加一个元素
s1={1,2,3,4,5,6,7,8,9}
s1.add(10)
print(s1) #输出{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
update()：一次至少添加一个元素
s1={1,2,3,4,5,6,7,8,9}
s1.update({20,19})
print(s1) #输出{1, 2, 3, 4, 5, 6, 7, 8, 9, 19, 20}
集合元素的删除
remove()：一次删除一个指定元素，若元素不存在则显示KeyError
s1={1,2,3,4,5,6,7,8,9}
s1.remove(5)
print(s1) #输出{1, 2, 3, 4, 6, 7, 8, 9}
discard()：一次删除一个指定元素，指定元素不存在不显示异常
s1={1,2,3,4,5,6,7,8,9}
s1.discard(5)
print(s1) #输出{1, 2, 3, 4, 6, 7, 8, 9}
pop()：一次只删除任意一个元素（不能添加参数）
s1={1,2,3,4,5,6,7,8,9}
s1.pop()
print(s1) #输出{2, 3, 4, 5, 6, 7, 8, 9}
clear()：清空集合
s1={1,2,3,4,5,6,7,8,9}
s1.clear()
print(s1) #输出set()
集合之间的关系
两个集合是否相等
使用运算符==或者!=
一个集合是否是另一个集合的子集
issubset()
s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5}
print(s1.issubset(s2)) #False
一个集合是否是另一个集合的超集
issuperset()
s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5}
print(s1.issuperset(s2)) #True
两个集合是否有交集
isdisjoint()：没有交集为True
s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5}
print(s1.isdisjoint(s2)) #False
集合之间的数据操作
求交集
s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5,10}
print(s1.intersection(s2)) #输出{1, 2, 3, 4, 5}
s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5,10}
print(s1 & s2) #输出{1, 2, 3, 4, 5}
求并集
s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5,10}
print(s1.union(s2)) #输出{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5,10}
print(s1 | s2) #输出{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
求差集
s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5,10}
print(s1.difference(s2)) #输出{8, 9, 6, 7}
s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5,10}
print(s1 - s2) #输出{8, 9, 6, 7}
求对称差集
s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5,10}
print(s1.symmetric_difference(s2)) #输出{6, 7, 8, 9, 10}
s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5,10}
print(s1 ^ s2) #输出{6, 7, 8, 9, 10}
集合生成式
{表示集合元素的表达式 for 自定义变量 in 可迭代对象}
s1={i*i for i in range(10)}
print(s1) #输出{0, 1, 64, 4, 36, 9, 16, 49, 81, 25}
字符串
字符串是一个不可变的字符序列，对相同的字符串（符合标识符的字符串）只保留一份拷贝
字符串的创建
字符串的操作
字符串的查询操作
index()：查找字符串第一次出现的位置，若字符串不存在，则显示ValueError
a='helloworld'
print(a.index('ow')) #输出4
rindex()：查找字符串最后一次出现的位置，若字符串不存在，则显示ValueError
a='helloworld'
print(a.rindex('l')) #输出8
find()：查找字符串第一次出现的位置，若字符串不存在，则显示-1
a='helloworld'
print(a.find('l')) #输出2
rfind()：查找字符串最后一次出现的位置，若字符串不存在，则显示-1
a='helloworld'
print(a.rfind('l')) #输出8
字符串的大小写转换操作
upper()：将字符串中所有的字符都转成大写字母
a='hello world'
print(a.upper()) #输出HELLO WORLD
lower()：将字符串中所有的字符都转成小写字母
a='hello WORLD'
print(a.lower()) #输出hello world
swapcase()：将字符串中所有的字符都转成大写字母，将字符串中所有的字符都转成小写字母
a='hello WORLD'
print(a.swapcase()) #输出HELLO world
capitalize()：把第一个字符转换为大写，其余转换为小写
a='hello WORLD'
print(a.capitalize()) #输出Hello world
title()：把每个单词的第一个字符转换为大写，单词的剩余字符转换为小写
a='hello WORLD'
print(a.title()) #输出Hello World
字符串的内容对其操作
center()：居中对齐，第一个参数表示宽度，第二个参数指定填充符默认是空格
ljust()：左对齐，第一个参数表示宽度，第二个参数指定填充符默认是空格
rjust()：右对齐，第一个参数表示宽度，第二个参数指定填充符默认是空格
zfill()：右对齐，左边用0填充
字符串内容的劈分
split()：从字符串的左边开始劈分，默认劈分字符是空格，返回列表，通过参数sep指定劈分字符，通过参数maxsplit指定最大劈分次数
a='hello world python'
print(a.split()) #输出['hello', 'world', 'python']
rsplit()：从字符串的右边开始劈分，默认劈分字符是空格，返回列表，通过参数sep指定劈分字符，通过参数maxsplit指定最大劈分次数
字符串内容的判断
isidentifier()：判断字符串是否是合法字符
isspace()：判断字符串是否都由空白字符组成
isalpha()：判断字符串是否都由字母组成
isdecimal()：判断字符串是否都由十进制的数字组成
isnumeric()：判断字符串是否都由数字组成
isalnum()：判断字符串是否都由字母和数字组成
字符串的替换与合并
字符串的替换
replace()：第一个参数指定被替换的子串，第二个参数指定替换子串的字符串，第三个参数指定最大替换次数
a='hello world world world'
print(a.replace('world','boy',2)) #输出hello boy boy world
字符串的合并
join()：将列表或元组中的字符串合并成一个字符串
a=['hello','world']
print('&'.join(a)) #输出hello&world
字符串的比较操作
使用运算符进行比较
比较规则：按顺序逐个比较字符串中的每一个字符
字符串的切片操作
字符串不具备增删改操作，切片会产生新的字符串
a=('hello,world')
print(a[:7]) #输出hello,w
格式化字符串
%占位符
name='小明'
age=10
print('我叫%s，今年%s岁'%(name,age)) #输出我叫小明，今年10岁
{}
name='小明'
age=10
print('我叫{0}，今年{1}岁'.format(name,age)) #输出我叫小明，今年10岁
f-string
name='小明'
age=10
print(f'我叫{name}，今年{age}岁') #输出我叫小明，今年10岁
字符串的编码与解码
编码
encode()：encoding指示编码种类
解码
decode()：encoding指示解码种类
函数
函数的创建与调用
函数的创建
def 函数名（参数）
函数体
return xxx
函数返回多个值时，结果为元组
函数的调用
函数名（实参）
函数的参数定义
使用*定义个数可变的位置参数
使用**定义个数可变的关键字参数
变量的作用域
局部变量
在函数内部定义使用的变量，只在函数内部有效，可以使用global变成全局变量
全局变量
函数外部定义的变量，可作用与函数内外
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
