Python基础语法
基本语法
注释
单行注释，以#开头
#这是第一个注释
print("Hello World") #这是第二个注释
多行注释：""“注释的内容”""
"""
这是一个多行注释
print("这是一个多行注释")
"""
行与缩进
Python最具特色的就是用缩进表示代码块
语句换行
Python通常是一行写完一条语句，但如果语句很长，我们需要换行，这时可以使用圆括号来实现
需要注意的是，在{},[]或()中的语句，不需要使用
变量和数据类型
变量
超市购物
现实生活中，大家去超市买东西的时候，往往都需要一个菜篮子，用来进行存储物品，等到所有的物品都购买完成后，在收银台进行结账即可。
Python中的变量用来存储数据，变量可以理解为去超市购物的菜篮子，其类型和值在赋值的那—刻被初始化。
num1=110
num2=120
result=num1+num2
注：num1和num2变量就好比一个小菜篮子，它们分别存储的数据是110和120。result变量存储的数据是num1和num2这两个“菜篮子”中的数据累计之和
变量的类型（变量用来储存数据）
-
变量的数据类型(以后补全详解)
- 1.数字类型（整型，复型，浮点型）
- 2.布尔类型
- 3.列表类型
- 4.元组类型
- 5.字符串类型
- 6.字典类型
标识符和关键字
标识符
定义：若希望在程序中表示一些事物，需要开发人员自定义一些符号和名称，这些符号和名称叫做标识符。
-
命名规则
- 1.标示符由字母、下划线和数字组成，且数字不能开头
- 2.Python中的标识符是区分大小写的
- 3.python中的标示符不能使用关键字 对于标识符的命名有以下建议：
- 1.见名知意
- 2.不建意使用骆峰式
关键字
定义：关键字是指具有特殊功能的标识符
help() #进入帮助系统
keywords #査看关键字列表
return #査看return
quit #退出
简单数值类型
整型（int，用于表示整数）
Python的整型可以表示的范围是有限的，它和系统的最大整型一致，例如，32位上的整型是32位，可以表示的数的围是-231-231-1。在64位机器上的整型是64位的，可以表示的数的范围是-263-263-1。
-
进制
-
二进制以0b,0B开头，十进制–>二进制
bin(20) -
八进制以0开头，十进制–>八进制
oct(20) -
十六进制以0x,0X开头，十进制–>十六进制
hex(20)
浮点型
浮点型(Float)用于表示实数。
浮点型字面值可以用十进制或科学计数法表示。
Python的浮点型遵循的是IEEE754双精度标准，每个浮点数占8个字节，能表示的数的范围是-1.8308~1.8308
<实数>E或者e<整数>
注：E或e表示基是10，后面的整数表示指数，指数的正负使用+或-表示。
实例：
print(1.2e5) #输出120000.0
print(-1.8e308) #输出-int，超出可以表示的范围
print(1.8e308) #输出int，超出可以表示的范围
复数类型
-
用于表示数学中的复数
- 复数由两部分抅成，实数部分和虚数部分（real+imageJ）
- 复数的实数部分和虚数部分都是浮点型
num_1=2+3.1j #定义复数
print(type(num_1)) #打印类型
print(num_1.real) #打印实部
print(num_1.imag) #打印虚部
数据类型转换
应用场景：有可能我们会碰到对采集到数据类型转换
num1=1.2 #定义浮点型
print(int(num1)) #打印，转换为整型
num2=4 #定义整数
print(float(num2)) #打印，转换为浮点型
print(complex(3,4)) #打印，#转换为复数
运算符
算术运算符
| 运算符 | 含义说明 |
|---|---|
| + | 加：两个对象相加 |
| - | 减：得到负数或另一个数减一个数 |
| * | 乘：两个数相乘或是返回一个被重复若干次的字符串 |
| / | 除：x除y |
| % | 取余数 |
| ** | 幂运算 |
| // | 取整除 |
num1=27
num2=3
num3=4
print(num1%num3) # %取余数
print(num2**num3) # **幂运算
print(num1//num3) # //取整除
复合赋值运算符
a=20
b=10
c=0
#加
c+=a
print("1--c的值为：",c)
#乘
c*=a
print("2--c的值为：",c)
# 除
c/=a
print("3--c的值为：",c)
#取余
c=2
c%=a
print("4--c的值为：",c)
#取幂
c=3
a=2
c**=a
print("5--c的值为：",c)
#取整除
c//=a
print("6--c的值为：",c)
比较运算符
a=20
b=10
c=0
if a==b:
print("1--a等于b")
else:
print("1--a不等于b")
if a!=b:
print("2--a不等于b")
else:
print("2--a等于b")
if a<b:
print("4--a小于b")
else:
print("4--a大于等于b")
if a>b:
print("5--a大于b")
else:
print("5--a小于等于b")
a=5
b=20
if a <= b:
print("6--a小于等于b")
else:
print("6--a大于等于b")
if a >= b:
print("7--a大于等于b")
else:
print("7--a小于b")
逻辑运算符
| 符号 | 表达形式 | 功能 |
|---|---|---|
| and | x and y | 布尔“与”，如果x为False，x and y 返回False，否则它返回y的计算值 |
| or | x or y | 布尔“或”，如果x为True，它返回True，否则它返回y的计算值 |
| not | not x | 布尔“非”，如果x为True，返回False，如果x为False， 它返回True |
a=10
b=20
if a and b:
print("1--变量 a 和 b 都为 true")
else:
print("1--变量 a 和 b 有一个不为 true")
if a or b:
print("2--变量 a 和 b 都为 true 或其中一个为 true")
else:
print("2--变量 a 和 b 都不为 true")
a=0
if a and b:
print("3--变量 a 和 b 都为 true")
else:
print("3--变量 a 和 b 有一个不为 true")
if a or b:
print("4--变量 a 和 b 都为 true 或其中一个为 true")
else:
print("4--变量 a 和 b 都不为 true")
if not(a and b):
print("5--变量 a 和 b 都为 false 或其中一个为 false")
else:
print("5--变量 a 和 b 都为 true")
成员运算符
| 符号 | 功能 |
|---|---|
| in | 如果在指定的序列中找到值则返回True |
| not in | 如果在指定的序列中没有找到值则返回True |
a=10
b=20
list_demo=[1,2,3,4,5]
if a in list_demo:
print("1--变量 a 在给定的列表 list_demo 中")
else:
print("1--变量 a 不在给定的列表 list_demo 中")
if b not in list_demo:
print("2--变量 a 不在给定的列表 list_demo 中")
else:
print("1--变量 a 在给定的列表 list_demo 中")
a=2
if a in list_demo:
print("3--变量 a 在给定的列表 list_demo 中")
else:
print("3--变量 a 不在给定的列表 list_demo 中")
位运算符``
| 名称 | 符号 | 含义 |
|---|---|---|
| 安位左移 | << | 按位左移指的是二进位全部左移n位，高位丢弃，低补0 |
| 安位右移 | >> | 按位右移指的是将二进位全部右移n位，移出的位丢弃，移进的位补符号位。按位右移的符号位保持不变 |
| 安位与 | & | 位与指的是参与运算的两个数各对应的二进位进行“与”的操作。只有对应的两个二进位都是1时，结果位就为1，否则结果位为0 |
| 安位或 | | | 按位或指的是参与运算的两个数各对应的二进位进行“或”的操作。只要对应的两个二进位有一个为1时，结果位就为1 |
| 安位异或 | ~ | 按位异或就是将参与运算的两个数对应的二进制位进行比较，如果一个位为1，另一个位为0，则结果为就为1，否则，结果位为0。 |
num1=10
print(bin(num1<<2))
print(bin(num1>>2))
num2=9
print(bin(num1&num2))
print(bin(num1|num2))
print(bin(num1^num2))
print(bin(~num2))
运算符优先级
a=20
b=10
c=15
d=5
e=0
e=(a+b)*c/d
print("(a+b)*c/d 运算结果为：",e)
e=((a+b)*c)/d
print("((a+b)*c)/d 运算结果为：",e)
e=(a+b)*(c/d)
print("e=(a+b)*(c/d) 运算结果为：",e)
e=a+(b*c)/d
print("e=a+(b*c)/d 运算结果为：",e)
判断语句
if语句
if语句是最简单的条件判断语句，它可以控制程序执行的流程。
格式：
if 判断条件 :
满足条件时要做的事1
满足条件时要做的事2
满足条件时要做的事3
。。。。。
满足条件时要做的事n
age=34
print("刘伟的年龄",age)
if age>=18:
print("刘伟已经成年")
print("刘伟未成年")
if-else语句
if 判断条件 :
满足条件时要做的事1
满足条件时要做的事2
满足条件时要做的事3
。。。。。
满足条件时要做的事n
else:
不满足条件时要做的事1
不满足条件时要做的事2
不满足条件时要做的事3
。。。。。
不满足条件时要做的事n
age=34
print("刘伟的年龄",age)
if age>=18:
print("刘伟已经成年")
else:
print("刘伟未成年")
ticket=1
if ticket==1:
print("有车票，可以上火车")
print("终于可以见到ta美滋")
else:
print("没有车票，可以上火车")
print("亲爱的，那就下次见了，一票难求QaQ")
if-elif
if 判断条件1 :
满足条件时要做的事1
elif 判断条件2:
满足条件时要做的事2
elif 判断条件3:
满足条件时要做的事3
过程
1.当满足判断条件1时，执行满足条件1时要做的
事情，然后整个if结束;
如果不满足判断条件1，那么判断是都满足条件
2.如果满足判断条件2，就执行满足条件2时要
做的事情，然后整个if结束
当不满足判断条件1和判断条件2，如果满足判
断条件3，则执行满足判断条件3时要做的事情，
然后整个if结束。
score=77
if score>=90 and score<=100:
print("本次考式，等级为A")
elif score>=80 and score<90:
print("本次考式，等级为B")
elif score>=70 and score<80:
print("本次考式，等级为C")
elif score>=60 and score<70:
print("本次考式，等级为D")
elif score>=0 and score<=60:
print("本次考式，等级为E")
if嵌套
if嵌套指的是在if-else语句里面包含if或者if-else
（1）语法
if 条件1
条件1满足执行语句1
。。。。。
if条件2
条件2满足执行语句2
。。。。。
ticket = 1
knife_lenght=9
if ticket==1:
print("有车票可以进")
if knife_lenght<10:
print("通过安检")
print("可以见到她美滋")
else:
print("没有通过安检")
print("刀子的长度超过了等处理")
else:
print("没有车票，不能进站")
print("亲爱的下次再见QaQ")
循环语句
while循环语法格式
while 条件表达式:
条件满足执行语句
var=int(input("请输入数字用于程序判定"))
while var==1:
number=int(input("请输入一个整数："))
print("请输入一个数字是",number)
print("Good bye！")
for 循环
格式
#使用序列
for i in [0,1,2]:
print(i)
#使用range函数
for i in range(2,8):
print(i)
#循环案例
i=0 #100之间的数
sum_result=0 #接受和
while i<=100:
if i%2==0: #判断是否为偶数
sum_result+=i #累加
i+=1
print("100之间的偶数和为{}".format(sum_result))
i=1
while i<6:
j=0
while j<i:
print("*",end=" ")
j +=1
print("\n")
i+=1
九九乘法表
i=1
while i<=9:
j=1
while j<=i:
print("%d*%d=%-2d"%(i,j,i*j),end=" ")
j +=1
print("\n")
i +=1
break语句
break的作用：跳出当前循环
i=0
for i in range(5):
i+=1
print("-------")
print(i)
break
i=0
for i in range(5):
i+=1
print("-------")
if i==3:
break
print(i)
continue语句
continue作用是用来结束本次循环，继续下次循环。
continue
i=0
for i in range(5):
i+=1
print("-------")
if i==3:
continue
print(i)
break与continue的区别，break是结束的整个循环，continue结束本次循环
pass语句
他是为了保持语句完整性，用作占位符
#pass
for letter in "Runoob":
if letter=="o":
pass
print("执行pass语句")
print("当前字母：",letter)
print("Good bye!")
#没有pass
for letter in "Runoob":
if letter=="o":
print("执行pass语句")
print("当前字母：",letter)
print("Good bye!")
else语句
else语句可和循环语句结合使用，在循环结束后执行
count=0
while count<5:
print(count,"is less than 5")
count+=1
else:
print(count,"is less than 5")
字符串
什么是字符串
概念：字符串是一种表示文本数据类型
表达形式：单引，双引，三引号引起来
转义字符
print('lets\'s go! go!')
格式化字符串
%s通过str()字符串转来格式化
%d有符号十进制整数
%f浮点实数
name="小明"
print("我的姓名%s"%name)
输入input
username=input(“请输入姓名：”)
print(username)
切片
格式
name="abcdef"
print(name[0:3])
print(name[3:5])
print(name[1:-1])
print(name[2:])
print(name[::-2])
find函数
含意：检测字符串是否包含子字符串
-
格式：
- str.find(sub,start,end)
- sub:待查找的子字符串
- start:查找的子字符串开姢的位置
- end:查找的子字符串结束的位置
str="oeopi oeioui oeiopei opeiop computer"
index=str.find("computer")
print(index)
注：找不到子字符串，则返回-1
index函数
含以：检测字符串是否包含子字符串
-
格式：
- str.find(sub,start,end)
- sub:待查找的子字符串
- start:查找的子字符串开姢的位置
- end:查找的子字符串结束的位置
str="oeopi oeioui oeiopei opeiop computer"
index=str.index("oeioui1",0,20)
print(index)
count函数
含以：统计词出现的个数
-
格式：
- str.count(sub,start=0,end=len(string))
- sub:待查找的子字符串
- start:查找的子字符串开姢的位置
- end:查找的子字符串结束的位置
string_example="hello world itheima and itheimaAPP"
result=string_example.count("itheima")
print(result)
replace函数
含意：将旧字符串换为新字符串
-
格式：
- str.replace(old,newf[,max])
- old:将被替换的旧子字符串
- new:替换的新子字符串
- max:替换的个数
string_example="hello world itheima and itheimaAPP"
new_string=string_example.replace("itheima","ITHEIMA",1)
print(new_string)
splite函数
含意：通过指定分符对字符串进行分割,切片
-
格式：
- str.split(str=" ",num=string.count(str))
- str–分割符。默认所有空字符串
- num–切割的次数
返回结果为一个列表
string_example="this is string example....wow!!!"
new_string_1=string_example.split(" ")
new_string_2=string_example.split("i")
new_string_3=string_example.split("i",2)#2-----切二次
print(new_string_1)
print(new_string_2)
print(new_string_3)
capitalize函数title函数
capitalize：第一个首字母大写
title：全部大写
string_example="this is string example....wow!!!"
print(string_example.title())
print(string_example.capitalize())
startswith函数
-
含意：检査字符串是否以制定子字符串开头
- str.startswith(str,beg=0,end=len(string))
- sub:检査的字符串
- beg:可选参数用于设置字符串检测的起始位置
- end:可选参数用于设置字符串检测的结束位置
string_example="this is string example....wow!!!"
print(string_example.startswith("this"))
print(string_example.startswith("iei"))
print(string_example.startswith("is",5))
endswith函数
含意：字符串或者元素
-
格式：
- str.endswith(suffix[,start[,end]])
- sub:检査的字符串
- start:可选参数用于设置字符串检测的起始位置
- end:可选参数用于设置字符串检测的结束位置
string_example="this is string example....wow!!!"
print(string_example.endswith("wow"))
print(string_example.endswith("!!!"))
print(string_example.endswith("iei"))
print(string_example.endswith("is",6))
upper函数
含意：将小写字母转大写
string_example="this is string example....wow!!!"
print(string_example.upper())
ljust和rjust函数
ljust:含意：左对齐，使用空格填充至指定长度
rjust:含意：右对齐，使用空格填充至指定长度
-
格式：
- str.ljust(width[,fillchar])
- width长度
-
fillchar默认是空格
rjust一样
string_example="this is string example....wow!!!"
r_new_string=string_example.rjust(50)
print(r_new_string)
l_new_string=string_example.ljust(50)
print(l_new_string)
center函数
含意：返回一个居中字符串
-
格式：
- str.center(width[,fillchar])
- width长度
- fillchar默认是空格
string_example="this is string example....wow!!!"
new_string=string_example.center(50)
print(new_string)
lstrip和rstrip函数
lstrip：含意：截掉字符串左辺的空格或指定字符串
rstrip：含意：截掉字符串右辺的空格或指定字符串
-
格式：
- str.lstrip([chars])
-
chars —指定删除
rstrip同上
#lstrip
string_example=" this is string example....wow!!!"
string_example_1=" this is string example....wow!!!"
new_string=string_example.lstrip()
new_string_1=string_example.lstrip()
print(new_string)
print(new_string_1)
#rstrip
string_example_2="this is string example....wow!!! "
new_string=string_example_2.rstrip()
print(new_string)
strip函数
含意：截掉字符串左右两辺的空格或指定字符串（两辺截）
-
格式：
- str.strip([chars])
- chars
string_example_2=" this is string example....wow!!! "
new_string=string_example_2.strip()
print(new_string)
*
含意：重复输出
print('t'*6)
print('一切皆有可能\n'*6)
+
含意：字符串拼接
print('一切皆'+'有可能')
列表，元组，字典
列表
列表的功能：列表是Python中的一个数据结构（是计算机存储，组织数据的方式），他可以存储不同的数据类型
list_example=["hello world",1,"Python"]
print(list_example[0])
print(list_example[1])
print(list_example[2])
使用for循环遍历列表中的元素
namelist=["hello world",1,"Python"]
for i in namelist:
print(i)
使用for循环遍历列表中的元素
namelist=["hello world",1,"Python"]
num=0
while num<len(namelist):
print(namelist[num])
num+=1
列表的对元素操作
在列表中增加元素
向列表中添加元素append添加到末尾
namelist=["hello world",1,"Python"]
namelist.append(input("添加的语言："))
print("添加后的列表元素为：")
for name in namelist:
print(name)
向列表中添加另一个列表entend
namelist=["hello world",1,"Python"]
name_list=["Java","MySQL"]
#append与entend对比
name_list.append(name_list)
print(name_list)
name_list.extend(name_list)
print(name_list)
向列表指定位置index添加元素insert
name_list=["hello world",1,"Python"]
name_list.insert(1,"JavaWeb")
print(name_list)
在列表中査找元素
in（存在），如果存在为true，否则false
not in（不存在），如果不存在那结果为true，否则为false
name_list=["hello world",1,"Python"]
name=input("请输入要查找的名字：")
if name in name_list:#注意类型
print("在列表中")
else :
print("不在列表中")
在列表中修改元素
使用下标修改列表中的元素
name_list=["hello world",1,"Python"]
name_list[0]="Java"
print(name_list)
删除列表中的元素
del：根据下标删除
name_list=["hello world",1,"Python"]
print("----删除之前----")
for name in name_list:
print(name)
del name_list[1]
print("----删除之后----")
for name in name_list:
print(name)
pop：删除最后一个元素
print("----删除之前----")
for name in name_list:
print(name)
name_list.pop()
print("----删除之后----")
for name in name_list:
print(name)
remove：根据元素的值进行删除
name_list=["hello world",1,"Python"]
print("----删除之前----")
for name in name_list:
print(name)
name_list.remove('hello world')
print("----删除之后----")
for name in name_list:
print(name)
元组
含意：与列表基本相同，但不能修改元素
tuple_1=("JavaWeb","Python",123)
tuple_2=("MySQL","html")
tuple_3=tuple_1+tuple_2
print(tuple_3)
for循环遍历元组
tuples=("MySQL","Java","Python",123,"JavaWed","Linux","hadoop")
for tuple in tuples:
print(tuple)
元组的内置含数
tuples=("MySQL","Java","Python",123,"JavaWed","Linux","hadoop")
#len(元组)计算元组元素的个数
print(len(tuples))
#max(元组)返回元组的最大值，min(元组)返回元组的最大值
tuple_1=("5","4","1")
print(max(tuple_1))
print(min(tuple_1))
#tuple(列表)，将列表转化为元组
list_demo=["Zookeeper","Hive","sqoop"]
print(tuple(list_demo))
字典
字典是一种存储数据的容器
格式：
info={'key1':'value1','key2':'value2'......}
字典操作
字典访问
使用键访问字典
info={"name":"班长","id":"1","sex":"f"}
print(info["name"])
print(info["id"])
get方法
获的字典中元素数据值提取
info={"name":"班长","id":"1","sex":"f","address":"北京"}
age=info.get("age")
print(age) #"age"键不存在，所以阿哥W为None
print(type(info))
name=info.get("name")
print(name)
age=info.get("age",18) #info中不存在“age”，返回默认值18
print(age)
字典的修改
格式：字典[键]=修改后的数据值
info={"name":"班长","id":"1","sex":"f","address":"北京"}
newId=input("请输入新的学号：")
info["id"]=int(newId)
print("修改之后的id为：%d"%info["id"])
字典中元素的添加
格式：字典[键]=数据值
字典中不存在键这个键时，是添加，如果存在是修改
info={"name":"班长","sex":"f","address":"北京"}
newId=input("请输入新的学号：")
print("添加之前字典：{}".format(info))
info["id"]=int(newId)
print("修改之后的id为：%d"%info["id"])
print("添加之后字典：{}".format(info))
删除字典
del：用于删除字；删除后，字典完全不存在了，无法根据字典键访问字典的值
clear：只是清空字典中的数据，字典还存在，只不过没有元素
info={"name":"班长","id":"1","sex":"f","address":"北京"}
print("清空之前的字典{}".format(info["name"]))
del info["name"]
print("清空之前的字典{}".format(info))
print("清空之后的字典{}".format(info["name"]))
info={"name":"班长","id":"1","sex":"f","address":"北京"}
print("清空之前的字典{}".format(info))
info.clear()
print("清空之后的字典{}".format(info))
计算字典中键值对得个数
len()
info={"name":"班长","id":"1","sex":"f","address":"北京"}
print("len计算字典的个数{}".format(len(info)))
获取视图函数
1.分类
keys()：方法返回在字典中的所有可用的键的列表
values()：方法返回在字典中的所有可用的值的列表
items()：方法返回在字典中的（键，值）元组对 `3·的列表
info={"name":"班长","id":"1","sex":"f","address":"北京"}
print("keys提取字典键{}".format(info.keys()))
print("values提取字典键{}".format(info.values()))
print("items提取字典键{}".format(info.items()))
遍历字典
1.遍历字典中的key
格式
for 变量名 in 字典名.keys():
循环体
dict_demo={"1":"MySQL","2":"Java","3":"mongodb"}
for dicts in dict_demo.keys():
print(dicts)
2.遍历字典中的value
格式
for 变量名 in 字典名.values():
循环体
dict_demo={"1":"MySQL","2":"Java","3":"mongodb"}
for dicts in dict_demo.values():
print(dicts)
3.遍历字典中的元素
格式
for 变量名 in 字典名.items():
循环体
dict_demo={"1":"MySQL","2":"Java","3":"mongodb"}
for dicts in dict_demo.items():
print(dicts)
4.遍历字典中的键值对
格式
for 变量名1, 变量名2.....变量名n in 字典名.items():
循环体
dict_demo={"1":"MySQL","2":"Java","3":"mongodb"}
for dict1,dict2 in dict_demo.items():
print("key={},value={}".format(dict1,dict2))
函数
什是函数：
函数是组织好的，可重复使用的，用来实现单一或相关联功能的代码块，他能提高代码的利用率
Python定义函数：
格式
def 函数名（参数列表）：
函数体
函数调用
格式
def 函数名（参数列表）：
函数体
函数名（参数列表）
def printInfo():
print("-----------------------")
print(" Python ")
print("-----------------------")
printInfo()
函数参数
我们在定以函数的时候让函接收数据，这就是函数参数
def printInfo(a,b):
c=a+b
print(c)
printInfo(10,11)
def test(a,b,*args):
print(a)
print(b)
print(args)
test(11,22)
test(11,22,33,44,55,66,77,88,99)
def test(a,b,*args,**kwargs):
print(a)
print(b)
print(args)
print(kwargs)
test(11,22)
test(11,22,33,44,55,66,77,88,99)
def test(a,b,*args,**kwargs):
print(a)
print(b)
print(args)
print(kwargs)
test(11,22)
test(11,22,33,44,55,66,77,m=88,n=99)
函数分类
无参无返回值类型
格式：
def 函数名:
函数过程
def def_main():
print("-"*20)
print("这是无参无返回值类型")
print("-"*20)
def_main()
无参有返回值类型
格式：
def 函数名:
函数过程
return 返回值
def def_main():
return "python"
str=def_main()
print(str)
有参无返回值类型
格式：
def 函数名(num1,num2):
函数过程
def def_main():
print("JavaWeb")
def_main()
有参有返回值类型
格式：
def 函数名(num1,num2):
函数过程
return 返回值
num=int(input("请输入一个数字："))
def def_main(num):
count=0
for i in range(0,num,1):
count +=i+1
return count
count_out=def_main(num)
print("1~{}的和为{}".format(num,count_out))
名片管理（未完善）
def display_manu():
print("-"*20)
print("1.添加")
print("2.修改")
print("3.删除")
print("4.査询")
print("5.获得所有名片")
print("6.退出")
print("-"*20)
def choice_use():
num=int(input("请输入："))
return num
def add_use(list_name):
name=input("请输入姓名：")
list_name.append(name)
return list_name
def remove_use(list_name):
name=input("请输入要删除的姓名")
list_name.remove(name)
return list_name
def replca_use(list_name):
pass
def select_use(list_name):
print(list_name[-1])
if __name__ == '__main__':
num=0
list_name = []
while num<1:
display_manu()
count=choice_use()
if count==1:
add_use(list_name)
elif count==2:
replca_use(list_name)
elif count==3:
remove_use(list_name)
elif count==4:
select_use(list_name)
elif count==5:
pass
elif count==6:
pass
elif count==7:
pass
else:
print("请重新输入：")
num=int(input("0再次査询，数入其它终止："))
函数嵌套
函数运行过程中调用另一个函数
作用域
num = 10
print(num)
for i in range(10):
num=i
print(num)
递归函数
一个函数在内部可以调用其它函数，但是，如果一个函数在内部不调用其它函数，而是自己本身的话，这个函数就是递归函数
阶乘案例：
def func(count):
if count==1:
result=1
else:
result=func(count-1)*count
return result
num=int(input("请输入一个整数："))
print("%d! ="%num,func(num))
匿名函数
定意
没有名字的函数
格式
如果要声明函数，则需要使用lambda关键字，匿名函数的声明
lambda [arg1 [,arg2,…argn]]:expression
arg:参数列表
expression：表达式
案例1
students=[
{"name":"list","age":18},
{"name":"dict","age":17},
{"name":"tuple","age":14},
{"name":"set","age":19},
]
students.sort(key=lambda x:x["name"])
print("name 排序",students)
students.sort(key=lambda x:x["age"])
print("sort 排序",students)
案例2
add = lambda a,b:a+b
print("运行结果：",add(10,20))
print("运行结果：",add(20,20))
案例3
def func(a,b,operation):
print("a=%d"%a)
print("b=%d"%b)
print("result=",operation(a,b))
func(11,22,lambda x,y:x+y)
print("-"*20)
func(11,22,lambda x,y:x-y)
日期时间函数
时间函数
在python中有，以下方式：
- 时间戳
- 格式化的时间字符串
- 时间元组
时间戳
时间戳表示的是从1970年1月1日00:00:00开始安秒计算的偏移量
import time; #导入摸块
ticks=time.time()
print("当前时间戳:{}".format(ticks))
格式化的时间字符串
- 例如：,time.localtime()
- 我们可以使用time模块的strftime方式格式化
- 在strftime方法配合使用格式化符号，P124 6.1
import time; #导入摸块
print(+++++++time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))
print(time.strftime("%y-%m-%d %H:%M:%S",time.localtime()))
时间元组
在数据处理的过程中，需要处理或者显示时间集合
日历含数
calendar.calendar(year,w=2,1=1,c=6)
import random
list_1=[]
for i in range(0,10,2):
list_1.append(random.randrange(10,100,2))
print(list_1)
print(random.choice(list_1))
print(random.choice("python"))
print(random.choice(["List","Dict","Tuple","Set"]))
print(random.choice(("List","Dict","Tuple","Set")))
def outer(start=0):
count=[start]
def inner():
count[0] +=1
return count[0]
return inner()
quoter=outer(5)
print(quoter)
def func(funcation):
def inner():
return funcation()
return inner
@func
def test():
return "大数据1901"
print(test())
def func_arg(args):
def func(funcation_name):
def func_in():
print("--日志-args=%s"%args)
funcation_name()
return func_in
return func
@func_arg("haha")
def test():
print("----test---")
test()
func=lambda x:x+2
result=map(func,[1,2,3,4,5])
print(list(result))
file=open("a.txt")
words=file.read(4)
print("读取数据是",words)
position=file.tell()
print("当前数据的位置",position)
words=file.read(8)
print("读取数据是",words)
position = file.tell()
print("当前数据的位置",position)
words=file.read(3)
print("读取数据是",words)
position = file.tell()
print("当前数据的位置",position)
file.close()
文件的删除
os中的remove(文件名)
import os
os.remove("data/test.txt")
**文件的夹创建 **
在当前 文件夹创建默认的文件mkdir(“文件名”)
import os
os.mkdir("./data/bigdata1901")
import os
# os.mkdir("张三")
path='张三'
old_path=os.getcwd()
print("当前文件夹是:%s"%old_path)
os.chdir(path)
new_path=os.getcwd()
print("修改后的文件夹是:%s"%new_path)
import os
def display_manu():
print("学生信息管理系统V1.0")
print("-"*20)
print("1.添加")
print("2.删除")
print("3.修改")
print("4.显示学生信息")
print("5.保存数据")
print("6.退出系统")
print("-"*20)
list_stu=[]
def add_info():
name=input("请输入姓名：")
sex=input("请输入性别（男/女）：")
phone=input("请输入手机号码：")
stu_info={}
stu_info['name']=name
stu_info['sex']=sex
stu_info['phone']=phone
list_stu.append(stu_info)
def remove_info():
num=int(input("请输入删除的序号"))
del list_stu[num-1]
def alter_info():
num=int(input("请输入俢改的序号"))-1
name=input("请输入姓名：")
sex=input("请输入性别（男/女）：")
phone=input("请输入手机号码：")
list_stu[num]["name"]=name
list_stu[num]["sex"]=sex
list_stu[num]["phone"]=phone
def print_info():
print("="*20)
print("学生信息：")
print("=*20")
print("序号 姓名 性别 手机号码")
stu_id=1
for i in list_stu:
print("%d %s %s %s"%(stu_id,i['name'],i['sex'],i['phone']))
stu_id +=1
def save_to_data():
file=open("backup.data",'w')
file.write(str(list_stu))
file.close()
def recover_data():
global list_stu
# 判断文件是否存在
if os.path.exists('student.data'):
f = open('backup.data','w+', encoding='utf-8')
# "[{'name': 'isaac', 'age': 18, 'gender': 'm'}]"
buf = f.read()
list_stu = eval(buf)
if __name__ == '__main__':
recover_data()
while True:
print(display_manu())
key=int(input("请输入数字:"))
if key==1:
add_info()
if key==2:
remove_info()
if key==3:
alter_info()
if key==4:
print_info()
if key==5:
save_to_data()
if key==6:
quit=input("是否确认？(Yes or No)")
if quit=='Yes':
break
else:
print('输入有误,重新输入')
异常
# print(stu_id)
# print(1/0)
# demo_list=[]
# demo_list[0]
# dict_demo={"1":"2"}
# dict_demo[1]
# f=open("demo")
# class Car(object):
# pass
# car=Car()
# car.color="block"
# print(car.color)
# print(car.age)
for i in range(1,10,2)
print(i)
class inputException(Exception):
#自定以异常类
def __init__(self,length,atleast):
self.length=length
self.atleast=atleast
try:
text=input("请输入密码：")
if len(text)<3:
raise inputException(len(text),3)
except EOFError:
print("你输入一个结束标记")
except inputException as result:
print("inputException 输入长度为{},输入长度至少应该为{}".format(result.length,result.atleast))
else:
print("没有异常")
扫一扫
19万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
