变量名、函数名、类名等统称为标识符
命名规范:
只能包含字母、数字、下划线
不能以数字开头
严格区分大小写
不能与系统关键字相同:keyword
系统关键字:
>>> 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']
>>>
不能与内置函数、模块名相同
尽量使用有意义的英文单词
变量名、函数名一般使用小写字母,类名一般使用大写字母开头的英文单词
变量是一种使用方便的占位符,来源于数学,是计算机语言中能储存计算结果或能表示值的抽象概念,用于引用计算机内存地址,该地址可以存储Script运行时可更改的程序信息。
变量可以保存程序运行时用户输入的数据、特定运算的结果等。简而言之,变量是用于跟踪几乎所有类型信息的简单工具。
python中声明变量非常简单,一句话概括就是,起个名字,给个值
变量命名方式
驼峰命名法
# 第一个单词小写,后面的每个单词首字母大写
studentName = '李四'
下划线分隔法(推荐)
# 多个单词间使用下划线连接
student_name = '李四'
例:
a,b,c = 1,2,3 # 声明3个变量,并分别赋值为1,2,3
a = 1,2,3,4,5 # 将多个值封包到一个元组中,赋值给变量
a,b = b,a # 交换2个变量的值
python 中的注释分为单行注释和多行注释
单行注释:#
多行注释:“somthing” 或者"““somthing””"
c = 1,2,3,4,5
print(c)
# name = '张三'
"""
多行注释
good
abc
"""
address = """
长字符串
贵州省
黔东南
dasfsdg
asdasdasdsdf
asd
"""
print(address)
1、输入输出
(1)输入
语法:input(['message'])
input函数用于接收外部的输入,所有输入都作为字符串处理
代码运行到input语句时会暂停,直到点击回车键
name=input("请输入姓名: ")
print(name,type(name))
(2) 输出
语法:print(value1.value2,....[,sep='x',end='x'])
value,待输出的值,可以同时输出多个
sep,输出多个值时,每个值之间的分隔符默认为空格
end,输出完成后的结尾符号,默认为换行符\n,如果想要输出后不换行可以用end="
name = input("请输入姓名: ")
age = input("请输入年龄: ")
print('*'*50)
print(name,age,sep=',',end='')
语法:%[-w.p]type
-
,表示左对齐,默认是右对齐
w
,宽度
p
,表示精度,主要用于浮点型数据
type
,表示数据类型(d -整数,f-浮点数, s -字符串)
name = '杨玉'
age = 20
weight = 50.978
print('姓名:%s, 年龄:%d, 体重:%.2f' %(name,age,weight))
print('-'*50)
print('姓名:%-8s\n年龄:%-8d\n体重:%8.1f' %(name,age,weight))
# 注意:使用时占位符与值必须要一一对应
语法:'{[:w.pf]}' .format(value)
w
,宽度
pf
,表示精度,主要用于浮点型数据
<
左对齐
^
,居中对齐
name = '杨雨'
age = 20
weight = 60.412
print('姓名:{}\n年龄:{}\n体重:{}' .format(name,age,weight))
print('*'*50)
print('姓名:{:8}\n年龄:{:<8}\n体重:{:^8.2f}' .format(name,age,weight))
语法:f'{var[:w.pf]}'
w
,宽度
pf
,表示精度,主要用于浮点型数据
>
,右对齐
^
,居中对齐
name = '杨玉'
age = 20
weight =50.987
print(f'姓名:{name}, 年龄:{age},体重:{weight}')
print('*'*50)
print(f'姓名:{name:^80}\n年龄:{age:>80}\n体重:{weight:.1f}')
函数 :type(obj)
都为不可变数据类型
整型:int
浮点型:float
布尔型:bool
值为:True 、False
不可变数据类型
声明:字符是包含在引号之间的内容,可以一对单引号、双引号、三引号
字符串方法:
语法:obj.function([参数])
upper()
,将字符串转换为大写,返回一个新的字符
lower()
,将字符串转换为小写,返回一个新的字符
title()
,将字符串中单词的首字母转换为大写,其余字母小写,返回一个新的字符
例1:
name ='maria_db'
print(name.upper())
print(name.lower())
print(name.title())
count(sub[start[,end]])
,统计在指定位置之间子字符串的数量
sub,待统计的子字符串
start,开始位置的索引(第一个位置索引为0,最后一个位置索引为-1)省略表示从索引为0开始
end,结束位置的索引(第一个位置索引为0,最后一个位置索引为-1,省略表示到索引为-1结束
name = 'maria_db'
print(name.count('a'))
print(name.count('a',2))
print(name.count('a',1,-3))
index(sub[start[,end]])
,返回子字符串在字符串中第一次出现的位置(索引)
不包含子字符串时提示错误
replace(sub,new[,count])
,将字符串中指定的字符串替换为新内容,可以通过count指定替换次数,返回一个新的字符串
name = '张阳阳'
print(name.replace('阳','*')
print(name.replace('阳','*',1))
strip()
,去除字符串两边的空字符(空格、\n、\t),返回一个新的字符串
split([sub])
,将一个字符串使用指定的子字符串进行分隔,返回一个列表,默认使用空格进行分割
name = 'abc ef,g\tm,np'
print(name.split())
print(name.split(','))
join(itea)
,将一个可迭代对象转换为字符串
li = ['abc', 'ef,g' 'm,np']
print(''.join(li))
print(','.join(li))
print('\t\t'.join(li))
isupper()
,检查字符串是否全为大写,如果是返回True,否则返回False
islower()
,检查字符串是否全为小写,如果是返回True,否则返回False
isalnum(),
检查字符是否由字母或者数字组成,如果是返回True,否则返回False
isalpha()
,检查字符是否由字母组成,如果是返回True,如果不是返回False
isdecimal()
,检查字符是否由数字组成,如果是返回True,如果不是返回False
encode()
,编码
decode()
,解码
startswith()
,检查字符串是否以指定内容开头,如果是返回True,否则返回False
endswith()
,检查字符串是否以指定内容结束,如果是返回True,否则返回False
[]
之间,每个元素之间使用逗号隔开,元素可以为任意数据类型index(obj)
,返回指定元素在列表中的索引,如果指定元素不存在则报错count(obj)
,返回指定元素在列表中的数量,如果指定元素不存在则返回0append(obj)
,将一个对象添加到列表末尾insert(index,obj)
,在指定索引处添加一个对象extend(iter)
,将一个可迭代对象的元素分别添加到列表li = [] # 声明一个空列表
li.append(1) # [1]
print(li)
li.append((1,2,3,4)) # [1, (1, 2, 3, 4)]
print(li)
li.insert(0,['a','b','c']) # [['a', 'b', 'c'], 1, (1, 2, 3, 4)]
print(li)
li.extend('abc') # [['a', 'b', 'c'], 1, (1, 2, 3, 4), 'a', 'b', 'c']
print(li)
pop([index])
,删除指定索引处的元素,默认删除最后一个元素remove(obj)
,删除指定元素,如果存在多个相同的元素,删除的是索引最小处的元素(从左往右数的第一个)clear()
,清空列表li = [1,1,2,3,1,4,1,5,6] # 声明一个列表
li.pop() # 删除最后一个元素
print(li) # [1,1,2,3,1,4,1,5]
li.pop(2) # 删除指定索引处的元素
print(li) # [1, 1, 3, 1, 4, 1, 5]
li.remove(1)
print(li) # [1, 3, 1, 4, 1, 5]
li.remove(1)
print(li) # [3, 1, 4, 1, 5]
li.clear()
print(li) # []
sort([key=xxx,reverse=True])
,排序
reverse()
,将列表元素反向copy()
,复制列表(在内存中开辟新地址保存相同内容)li = [['a',100],['d',97],['b',99]] # 声明一个列表
a = li # 将变量li保存的地址赋值给变量a
print(a == li) # True
print(a is li) # True
b = li.copy() # 在内存中新开辟地址保存列表li的内容,将新地址赋值给变量b
print(b == li) # True
print(b is li) # False
print(id(a),id(li),id(b)) # 140301576496064 140301576496064 140301576496384
{}
之间,元素以键值(key:value)对形式存在,key必须为不可变数据类型,value可以是任意数据类型dic[key] = value
,如果key不存在,则新增键值对dic[key] = value
,key存在dic[key]
dic = {'name':'张三',('age',):20,100:[1,2,3,4],True:1,3.14:'PI'} # 声明字典
# 字符串、元组、int、float、bool属于不可变类型,可以作为字典的键
print(dic)
print(dic['name']) # 访问键值对
dic['name'] = '李四' # 键'name'存在,则完成修改动作
print(dic)
dic['phone'] = '13512345678' # 新增键值对
print(dic)
内置方法
get(key)
,返回指定键的值,如果key不存在,返回Noneupdate(key=value)
,新增键值对,如果key存在则实现修改动作dic = {'a':1,'b':2} # 声明字典
dic.update(c=3) # {'a': 1, 'b': 2, 'c': 3}
print(dic)
dic.update(a=3) # {'a': 3, 'b': 2, 'c': 3}
print(dic)
setdefault(key,value)
,如果key存在,返回对应的值;如果key不存在,则在字典中新增键值对,返回value
dic = {'a':1,'b':2} # 声明字典
print(dic.setdefault('a',100)) # 1
print(dic.setdefault('aaa',100)) # 100
print(dic) # {'a': 1, 'b': 2, 'aaa': 100}
pop(key)
,删除指定键值对popitem()
,随机删除一个键值对keys()
,以dict_keys格式返回字典中所有的键values()
,以dict_values格式返回字典中所有的值()
之间,每个元素之间使用逗号隔开,元素可以为任意数据类型index(obj)
,返回指定元素在元组中的索引,如果指定元素不存在则报错count(obj)
,返回指定元素在元组中的数量,如果指定元素不存在则返回0声明:包括在{}之间,元素可以时任意数据类型,集合中过的元素是唯一的
set(obj)
,将一个可迭代对象转换为集合,自动去重
int(obj)
,转换为整型
float(obj)
,转换为浮点型
bool(obj)
,转换为布尔型
str(obj)
, 转换为字符串
list(obj)
,将可迭代对象转换为列表
内置方法中包含_ _iter_ _
方法对象称为可迭代对,主要有str、list、tuple、dict、set
元素访问
切片操作
obj[[start]:[end][:step]]
start
,开始为位置的索引,如果省略表示索引为0,包括在结果中
end
,结束位置的索引,如果省略表示索引为-1。end索引处的元素不包括在结果中
step
,步长,表示间隔多少个元素取一个,默认步长为1(表示依次取)
例:
li = [1,2,3,4,5,6,7,8]
print(li[1:5]) # [2, 3, 4, 5]
print(li[1:5:2]) # [2, 4]
print(li[1:]) # [2, 3, 4, 5, 6, 7, 8]
print(li[:]) # [1, 2, 3, 4, 5, 6, 7, 8]
print(id(li),id(li[:]))
a = li[::-1] # [8, 7, 6, 5, 4, 3, 2, 1]
print(a)
print(li)
len(iter)
,返回可迭代对象中的元素数量sum(iter)
,返回可迭代对象中所有元素的和max(iter)
,返回最大值del iter
,删除指定对象li = [1,2,3,4,5,6,7,8,9]
print(len(li)) # 9
print(sum(li)) # 45
print(max(li)) # 9
del li[0] # 删除列表的第一个元素
print(li) # [2, 3, 4, 5, 6, 7, 8, 9]
del li[4:] # 删除列表中第5个元素开始的所有内容
print(li) # [2, 3, 4, 5]
del li # 删除列表
+,返回两个对象的和,参数运算符的对象数据类型为int或者float
如果参与运算的对象为两个字符串,实现的是字符串拼接
-,返回两个对象的差,参数运算符的对象数据类型为int或者float
*,返回两个对象的乘积,参数运算符的对象数据类型为int或者float
如果参与运算的对象为一个整数一个字符串,实现的是将字符串复制n次
/,返回两个对象的商,参数运算符的对象数据类型为int或者float
//,整除(地板除),返回小于等于两个对象商的最大整数(向下取整)
5//2 = 2
5//-2 = -3
%,返回两个对象相除的余数
公式:`r = a%b = a-b*(a//b)`
5%2 = 1
5%-2 = -1
**,幂运算
3**2 = 9
3**0.5 = 1.73
例1:输入1个四位的正整数,计算出这个数每一位上数字的和
# 方法一:通过索引获取每一位上数字
number = input('请输入1个四位正整数:')
# 获取每一位上的数字
# 通过索引获取每一位上的数字
unit = int(number[-1]) # 个位数
ten = int(number[-2] ) # 十位
hun = int(number[1]) # 百位
th = int(number[0]) # 千位
# 求和
s = unit+ten+hun+th
print(f'{number}每一位上数字的和为:{s}')
# 方法二:通过算术运算获取每一位上数字
number = input('请输入1个四位正整数:')
number = int(number)
# 获取每一位上的数字
unit = number%10 # 个位数
ten = number%100//10 # 十位
hun = number%1000//100 # 百位
th = number//1000 # 千位
# 求和
s = unit+ten+hun+th
print(f'{number}每一位上数字的和为:{s}')
例2:有一个列表students中保存有学生的成绩信息—[[1001,'张三',89,90,91,270,90.00],[1002,'李四',89,90,91,270,90.00]]
,每个学生的成绩存在一个子列表中,依次表示学号、姓名、语文、数学、英语、总分、平均分。输入一个新的学生学号、姓名和各科成绩,其总分和平均分计算出来后保存到列表students中
students = [[1001,'张三',89,90,91,270,90.00],[1002,'李四',89,90,91,270,90.00]]
tmp = [] # 保存每一个学生信息
no = int(input('学号:'))
name = input('姓名:')
ch = int(input('语文:'))
mth = int(input('数学:'))
eng = int(input('英语:'))
total = ch+mth+eng # 总分
avg = f'{total/3:.2f}' # 平均分
tmp = [no,name,ch,mth,eng,total,float(avg)]
students.append(tmp)
print(students)
a += 1
相当于a = a+1
运算结果为True或者False
==
,判断两个对象的值是否等!=
>
>=
<
<=
运算结果为True或者False
and
,参与运算的两个对象结果都为True,则整体表达式结果为True,否则结果为False
左边表达式结果为False时,右边表达式不会运行
a,b,c = 10,20,30
tmp = a>10 and (b:=21)>20 # a>10结果为False,(b:=21)>20表达式不运行,故b的值不变
print(tmp)
print(b) # 20
or
,参与运算的两个对象结果都为False,则整体表达式结果为False,否则结果为Truea,b,c = 10,20,30
tmp = a>1 or (b:=21)>20 # a>1结果为True,(b:=21)>20表达式不运行,故b的值不变
print(tmp)
print(b) # 20
not
,参与运算的对象结果为False,则整体表达式结果为True,否则结果为False运算结果为True或者False
in
,
'name' in ['name','age'] = True
'a' in {'a':1,'b':2} = True
,检查的是键
not in
value1 if 布尔表达式 else value2
,如果布尔表达式结果为True,返回value1,否则返回value2name = input('姓名:')
score = int(input('成绩:'))
result = '合格' if score >= 60 else '不合格'
print(f'姓名:{name}\t成绩:{result}')
例1:输入一个学生的姓名、成绩,如果成绩大于等于90,输出A,成绩在[70,89],输出B,在[60,69],输出C,小于60输出D
name = input('姓名:')
score = int(input('成绩:'))
result = 'A' if score >= 90 else ('B' if score >= 70 else ('C' if score >= 60 else 'D'))
print(f'姓名:{name}\t成绩:{result}')
检查两个对象是否引用同一个地址,运算结果为True或者False
<<