输出语句
print()
#若有字符串
print('helloworld')
print("helloworld")
#含有运算符
print(3+1)
#结果:4
#输出结果进行不换行输出(输出内容在一行中)
print('hello','world','Python')
#输出结果: hello world Python
#转义字符:\n:空行 \t:水平制表符 \r:回车 \b:退格
print('hello\nworld')
#结果:
#hello
#world
print('hello\tworld')
#结果:hello world
#四个空格为一个\t
print('hello\rworld')
#结果:world
#因为\r后面是world会覆盖前面的hello
print('hello\bworld')
#结果:hellworld (少了个o)
#若要输出 ‘ “ \ 等符号,即需要在输出字符前面加上\
#eg:
print('http:\\\\www.baidu.com')
#结果:http:\\www.baidu.com
print('老师说:\'大家好\'')
#结果:老师说:‘大家好’
#原字符,不希望字符串中的转义字符起作用,就使用原字符,用法:在字符串之前加上r或R
print(r'hello\nworld')
#注意事项:最后一个字符不能是反斜杠
#eg:print(r'helloworld\') 会报错
#但是可以是:print(r'helloworld\\') 双斜杠就是输出一个反斜杠
将数据输出文件中
#注意:1.所指定盘符存在 2.使用 file = fp
#eg:
fp=open('文件路径','a+') #如果文件不存在就创建,存在就在文件内容后面继续追加
print('helloworld',file=fp)
fp.close() #打开了文件就要关闭文件
二进制与字符编码
8bit(位)=1byte(字节)
1024byet=1KB(千)
1024KB=1MB(兆)
1024MB=1GB()
1024GB=1TB(太)
保留字
#查看保留字
impory keyword
print(keyword.kwlist) #即可查看
变量
name=‘康康’ #变量名就叫name,而等号就是赋值的意思,等号右边变量的值。
print(name) #输出括号里面可以直接放变量即可输出变量的值
#结果:康康
#若再次赋值即会改变变量的值
name='小敏'
print(name)
#结果:小敏
数据类型:
常用数据类型:
- 整数类型 -> int -> 98
- 浮点数类型 -> float -> 3.14159
- 布尔类型 ->bool -> True,Flase (有两个,一个是正确的,一个是错误的)
- 字符串类型 -> str -> '人生苦短,我用Python'
类型转换:
name='张三'
age=21
print('我叫'+name+'今年,'+age+'岁') #str类型和int类型不能在一句话中同时使用,会报错,得使用类型转换
#改后(类型转换)
print('我叫'+name+'今年,'+str(age)+'岁') #int类型的age变成str类型输出
Python注释:
#单行注释
'''多行
注释
前三个单引号
后三个单引号'''
input函数
#input类型是str类型
#eg:
a=input('请输入一个加数:')
b=input('请输入另一个加数:')
print(a+b)
'''控制台输出:
请输入一个加数:10
请输入另一个加数:20
'''
#结果:1020 起到链接作用
#若想用int类型相加:
a=int(input('请输入一个加数:'))
b=int(input('请输入另一个加数:'))
print(a+b)
'''控制台输出:
请输入一个加数:10
请输入另一个加数:20
'''
#结果:30
运算符
算术运算符:
'''加(+) 减(-) 乘(×) 除(/) 整除(//) 取余(%) 次方(**)
整除就是取除数的整数部分
eg:11//5 等于 2
11%2 等于1
2**3 等于8
支持参数赋值:+=、-=、*=、/=、//=、%=
支持系列解包赋值:a,b,c=20,30,40
交换两个变量的值:
a,b=10,20
print('交换之前:',a,b)
#结果:
交换之前:10 20
a,b=b,a
print('交换之后;',a,b)
结果:
交换之后:20 10
'''
比较运算符:
a,b=10,20
print('a>b吗?',a>b) #False
print('a<b吗?',a<b) #True
print('a<=b吗?',a<=b) #True
print('a>=b吗?',a>=b) #False
print('a==b吗?',a==b) #False
print('a!=b吗?',a!=b) #True(!= 不等于)
#比较两个变量是否相等
a=10
b=10
print(a==b) #True 说明,a与b的value相等
print(a is b) #True 说明,a与b的id标识相等
#以下是数组,相当于一个容器,能够存储很多个数值
list1=[11,22,33,44]
list2=[11,22,33,44]
print(list1==list2) #True 比较的是value
print(list1 is list2) #False 比较的是id标识
#不相等(is not)
print(list1 is not list2) #True
布尔运算符:
'''
a,b=1,2
--------------- and 并且 ------------------
tip:and 的意思就是两者都要符合才能为True
print(a==1 and b==2) #True
print(a==1 and b<2) #False
--------------- or 或者 ------------------
tip:or 的意思是两者有一个存在即可为True
print(a==1 or b<2) #True
print(a!=1 or b==2) #True
--------------- not 对bool类型操作数取反 -----------------
f=True
f2=False
print(not f) #False
print(not f2) #True
--------------- in 或 not in -----------------
in和not in 的意思是这个字符串是否在你所查询的字符串里面存在
eg:
s='helloworld'
print('w' in s) #True
print('k' in s) #False
'''
位运算:
print(4&8) #结果:0
#按位与& 同时1时结果为1
print(4|8) #结果:12
#按位或| 同时0时结果为0
print(4<<1) #向左移动1位(相当于乘以2)
#结果:8
print(4<<2) #向左移动2位
#结果:16
print(4>>1) #向右移动1位,相当于除以2
#结果:2
print(4>>2) #向右移动2位,相当于除以4
#结果:1
优先级:算术运算符 --> 位运算 --> 比较运算符 --> 布尔运算符 --> 赋值运算符(高-->低)
对象的布尔值:
---------------以下对象的布尔值为False--------------------
print(bool(False)) #False
print(bool(0)) #False
print(bool(0.0)) #False
print(bool(None)) #False
print(bool('')) #False
print(bool("")) #False
print(bool([])) #空列表
print(bool(list())) #空列表
print(bool()) #空元组
print(bool(tuple())) #空元组
print(bool({})) #空字典
print(bool(dict())) #空字典
print(bool(set())) #空集合
-------------其他对象的布尔值均为True--------------------
if语句
#if条件成立即可运行下面语句
#单分支结构
#eg:
money=1000
s=int(inpt('请输入取款金额')) #input函数
#判断余额是否充足
if money>=s:
money=money-s
print('取款成功,余额为:',money)
#双分支结构
num=int(input('请输入一个整数'))
#条件判断
if num%2==0:
print(num,'是偶数')
else:
print(num,'是奇数')
# 多分支结构
# eg(成绩等级):
score = (int)(input('请输入一个成绩'))
# 判断
if 90 <= score <= 100:
print('A级')
elif 80 <= score <= 89:
print('B级')
elif 70 <= score <= 79:
print('C级')
elif score >= 60 and score <= 69:
print('D级')
elif score >= 0 and score <= 69:
print('E级')
else:
print('对不起,成绩有误,不在成绩的有效范围')
#嵌套if
answer=input('您是会员吗?y/n')
money = float(input('请输入您的购物金额'))
#外层判断是否是会员
if answer=='y':
if money>=200:
print('打8折,付款金额为:',money*0.8)
elif money>=100:
print('打9折,付款金额为:',money*0.9)
else:
print('不打折,付款金额为:',money)
else:
if money>=200:
print('打9.5折,付款金额为:',money*0.95)
else:
print('不打折,付款金额为:',money)
#嵌套if
answer=input('您是会员吗?y/n')
money = float(input('请输入您的购物金额'))
#外层判断是否是会员
if answer=='y':
if money>=200:
print('打8折,付款金额为:',money*0.8)
elif money>=100:
print('打9折,付款金额为:',money*0.9)
else:
print('不打折,付款金额为:',money)
else:
if money>=200:
print('打9.5折,付款金额为:',money*0.95)
else:
print('不打折,付款金额为:',money)
pass语句:什么都不做,只是占位符,用在语法上需要语句的地方
#就比如在if-else语句中需要用到
int num=1
if num==1:
pass
else:
pass
#也就是说可以先让程序运行起来并且不报错,但是pass语句并没有任何意义
range()函数
#创建range对象的三种方式
'''
1.range(stop)--> 创建[0,stop)之间的整数序列,步长为1
2.range(start,stop) --> 创建一个[start,stop)之间的整数序列,步长为1
3.range(star,stop,step) --> 创建一个[start,stop)之间的整数序列,步长为step
'''
#第一种创建方式,只有一个参数 ( 参数:小括号里面给了一个数)
r=range(10) #[0,1,2,3,4,5,6,7,8,9],默认从0开始,默认相差1称为步长
print(r) #range(0,10)
print(list(r))
#第二种创建方式,。,给了两个参数 ( 参数:小括号里面给了两个数)
r=range(1,10)
print(list(r)) #[1,2,3,4,5,6,7,8,9]
#第三钟创建方式,给了三个参数 (参数:小括号里面给了三个数)
r=range(1,10,2)
循环表达式:
- 选择结构的if与循环结构while的区别:
- if是判断一次,条件为true执行一行
- while是判断N+1次,条件为True执行N次
a=1
#判断条件表达式:
while a<10:
#执行条件执行体
print(a)
a+=1
#结果:1 2 3 4 5 6 7 8 9
#例题:从1加到10结果为多少?
a=1
sum=0
while a<11:
sum=sum+a
a+=1
print(sum)
#结果:55
for - in循环
for item in 'Python':
print(item)
#结果: P y t h o n (逐个输出)
for i in range(10):
print(i)
#结果:0 1 2 3 4 5 6 7 8 9
水仙花数:输出100~999之间的水仙花数
- 举例:153=3*3*3+5*5*5+1*1*1
for item in range(100,1000):
ge=item%10 #个位
shi=item//10%10 #十位
bai=item//100 #百位
if ge**3+shi**3+bai**3==item:
print(item)
流程控制语句break:
- 直接退出最里层循环体
#eg:输入密码:
a=0
while a<3:
'''条件执行体'''
pwd=input('请输入密码:')
if pwd=='8888':
print('密码正确')
break
else:
print('密码不正确')
'''改变变量'''
a+=1
continue语句:
- 用于结束当前循环,进入下一次循环,通常与分支结构中if一起使用
#例:输出1~50之间5的倍数
for item in range(1,51):
if item%5!=0:
continue
print(item)
嵌套循环:
#99乘法表
for i in range(1,10): #行数
for j in range(1,i+1):
print(i,'*',j,'=',i*j,end='/t')
print()
列表:
列表的特点:
- 列表元素按顺寻有序排序
- 索引映射唯一一个数据
- 列表可以存储重复数据
- 任意数据类型混存
- 根据需要动态分配和回收内存
列表的创建:
#创建列表的第一种方式,使用[]
lst=['hello','world',98]
print(lst)
print(lst[0])
print(lst[-3])
'''结果:
['hello','world',98]
hello
hello
'''
#创建列表的第二种方式,使用内置函数list()
lst2=list(['hello','world',98])
列表的查询操作:
- 获取列表中指定元素的索引
lst=['hello','world',98,'hello']
print(lst.index('hello'))
#print(lst.index("Python")) #ValueError: 'Python' is not in list
#print(lst.index('hello',1,3)) #ValueError: 'hello' is not in list 'world',98
print(lst.index('hello',1,4))
#结果:
0
3
列表元素的查询操作:
- 获取列表中的多个元素
- 语法格式
- 列表名[start : stop : step]
增加操作 | 方法/其他 | 操作描述 |
append() | 在列表的末尾添加一个元素 | |
extend() | 在列表的末尾至少添加一个元素 | |
insert() | 在列表的任意位置添加一个元素 | |
切片 | 在列表的任意位置添加至少一个元素 |
lst=[10,20,30]
lst.append(100) #lst=[10,20,30,100]
lst2=['hello','world']
lst.append(lst2) #将lst2作为一个元素添加到列表的末尾
#lst=[10,20,30,100,['hello','world']]
lst.extend(lst2)
#向列表的末尾一次性添加多个元素
#lst=[10,20,30,100,'hello','world']
#在任意位置上添加一个元素
lst.insert(1,90)
print(lst)
#结果:lst=[10,90,20,30,100,'hello','world']
lst3=[True,False,'hello']
#在任意的位置上添加N多个元素
lst[1:]=lst3
print(lst)
#结果:[10,True,False,'hello']
列表元素的删除操作:
删除操作 | 方法/其他 | 操作描述 |
remove () | 一次删除一个元素 | |
重复元素只删除第一个 | ||
元素不存在抛出ValueError | ||
pop() | 删除一个指定索引位置上的元素 | |
指定索引不存在抛出IndexError | ||
不指定索引,删除列表中最后一个元素 | ||
切片 | 一次至少删除一个元素 | |
clear() | 清空列表 | |
del | 删除列表 |
lst=[10,20,30,40,50,60,30]
lst.remove(30) #重复元素只删除第一个
print(lst)
#结果:[10,20,40,50,60,30]
#pop()根据索引移除元素
lst.pop(1)
print(lst)
#结果:[10,40,50,60,30]
lst.pop() #不指定索引,删除列表中最后一个元素
print(lst)
#结果:[10,40,50,60]
#切片操作-至少删除一个元素,将产生一个新的列表对象
new_list=lst[1:3]
print(lst) #[40,50]
print(new_list) #[10,60]
列表元素的修改操作:
- 为指定索引的元素赋予一个新值
- 为指定的切片赋予一个新值
lst=[10,20]
#一次修改一个值
lst[1]=100
#[10,100]
lst[0:1]=[300,400,500]
print(lst)
#结果:[10,300,400,500,100]
列表元素的排序操作:
- 常见的两种方式:
- 调用sort()方法,列表的所有元素默认按照从小到大的顺寻进行排序,可以指定reverse=True,进行降序排序
- 调用内置函数sorted(),可以指定reverse=True,进行降序排序,原列表不发生改变
lst=[20,40,10,98]
lst.sort()
print(lst)
#结果:[10,20,40,98]
lst.sort(reverse=True)
print(lst)
#结果:[98,40,20,10]
lst.sort(reverse=False)
print(lst)
#结果:[10,20,40,98]
#调用内置函数sorted()
lst=[20,40,10,98,54]
new_list=sorted(lst)
print(new_list)
#结果:[10,20,40,54,98]
desc_list=sorted(lst,reverse=True)
print(desc_list)
#结果:[98,54,40,20,10]
列表生成式:
- 语法格式:
lst=[i for i in range(1,10)]
print(lst)
lst=[i*i for i in range(1,10)]
print(lst)
'''
结果:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 4, 9, 16, 25, 36, 49, 64, 81]
'''
字典:key不允许重复,value可以重复
字典的创建:
#使用{}创建字典
scores={'张三':100,'李四':98,'王五':45}
#第二中国创建 dict()
student=dict(name='jack',age=20)
print(student)
#结果:{'name':'jack','age':20}
#空字典
d={}
print(d)
#结果:{}
获取字典的元素:
scores={'张三':100,'李四':98,'王五':45}
#第一种方式,使用[]
print(scores['张三'])
#结果:100
#第二种方式,使用get()方法
print(scores,get('张三'))
#结果:100
#若不存在 [] 会报错,而使用get方法却不会报错,会返回None
字典的增删改操作:
scores={'张三':100,'李四':98,'王五':45}
del scores['张三'] #删除指定的key-value对
print(scores)
scores['陈六']=98 #新增元素
print(scores)
scores['陈六']=100 #修改元素
print(scores)
'''结果:
{'李四': 98, '王五': 45}
{'李四': 98, '王五': 45, '陈六': 98}
{'李四': 98, '王五': 45, '陈六': 100}
'''
获取字典视图:
- key():获取字典中所有key
- value():获取字典中所有value
- items():获取字典中所有key,value对
字典元素的遍历:
scores={'张三':100,'李四':98,'王五':45}
#字典元素的遍历
for item in scores:
print(item,scores[item],scores.get(item))
'''
结果
张三 100 100
李四 98 98
王五 45 45
'''
字典生成式:
item=['Fruits','Books','Others']
prices=[96,78,85,100,120]
d={item.upper():price for item,price in zip(items,prices)}
print(d)
#结果:
{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}
函数:
函数的创建:
def calc(a,b): #a,b称为形式参数,简称形参,形参的位置是在函数的定义处
c=a+b
return c
函数的调用:
result=calc(10,20) #10,20称为实际参数的值,简称实参,实参的位置是函数的调用处
print(result)
res=calc(b=10,a=20) # =左侧的变量的名称称为 关键字参数
print(res)
函数的返回值:
def fun(num):
odd=[] #存奇数
even=[] #存偶数
for i in num:
if i%2:
odd.append(i)
else:
even.append(i)
return odd,even
#函数的调用
lst=[10,29,34,23,44,53,55]
print(fun(lst))
#结果:
([29, 23, 53, 55], [10, 34, 44])
- 如果函数没有返回值【函数执行完毕之后,不需要给调用处提供数据】 return可以省略不写
- 函数的返回值,如果是1个,直接返回类型
- 函数的返回值,如果是多个,返回的结果为元组
函数参数定义_默认值参数:
def fun(a,b=10): #b称为默认值
print(a,b)
#函数的调用
fun(100)
fun(20,30)
#结果:
100 10
20 30
函数的参数定义:
- 个数可变的位置参数
- 定义函数时,可能无法事先确定传递的位置实参的个数时,使用可变的位置参数
- 使用*定义个数可变的位置形参
- 结果为一个元组
def fun(*args):
print(args)
fun(10)
fun(10,30)
fun(30,405,50)
#结果:
(10)
(10,30)
(30,405,50)
- 个数可变的关键字形参
- 定义函数时,无法事先确定传递的关键字实参的个数时,使用可变的关键字参数
- 使用**定义个数可变的关键字形参
- 结果为一个字典
def fun1(**args):
print(args)
fun1(a=10)
fun1(a=20,b=30,c=40)
#结果:
{'a': 10}
{'a': 20, 'b': 30, 'c': 40}
变量的作用域:
- 局部变量:
- 在函数内定义并使用的变量,只在函数内部有效,局部变量使用global声明,这个变量就会成全局变量
def fun(a,b):
c=a+b #c,就称为局部变量,因为c是函数体内进行定义的变量,a,b为函数的形参,作用范围也是函数内部,相当于局部变量
print(c)
def fun2():
global age #函数内部定义的变量,局部变量,局部变量使用global声明,这个变量实际上就变成了全局变量
age=20
print(age)
-
全局变量
- 函数体外定义的变量,可作用于函数内外
name='张三' #name的作用范围为函数内部和外部都可以使用 -->称为全局变量
print(name)
def fun3():
print(name)
递归函数:
- 函数还可以自我调用,这种类型的函数被称为递归函数。