day1
1.
布尔类型:布尔类型只有两个值,false和true
特殊注释:一般在文件的第一,二行
#!/usr/bin/env python3; :为了解释python的解释器在哪个位置,而在windows系统中系统可以通过环境变量直接获取到解释器的位置。
# - - coding=utf-8 - - :为了指定当前文件可以用中文,而python3默认可以用中文。
所以以上注释很少见了。
input:输出格式是str类型,字符串类型的
{} .foemat:填坑和输出,配合使用。
day2
2.
选择流程,多分支:
开头 if 条件表达式 :
elif 条件表达式(可以有很多个) :
结尾 else 条件表达式 :
pass:空语句,结束代码块的运行
循环流程:
for ... in 可迭代的集合对象
和C语言不一样,记录一下。
做了一个猜拳的小游戏
import random
#计算机 人
#0:石头 1:剪刀 2:布
person=int(input('请出拳【0:石头 1:剪刀 2:布】:'))
computer=random.randint(0,2)
print('%d' %(computer))
if person==0 and computer==1:
print('恭喜你,你赢了')
pass
elif person==1 and computer==2:
print('恭喜你,你赢了')
pass
elif person==2 and computer==0:
print('恭喜你,你赢了')
pass
elif person==computer:
print('hh,真巧啊')
pass
else:
print('你输啦!')
pass
print('GAME OVER!')
3.
break:代表中断结束,满足条件直接结束本层循环。(也就是结束该段的循环流程,进入下一个流程)
continue:结束本次循环,开始下一次循环。(也就是说结束本次循环流程,进入下一次的循环,还是本层的循环)
while:适用于对未知循环次数,用于判断
for:用于对已知的循环次数【可迭代对象遍历】
for-else和while-else结构
没有执行break,else就会执行。
day3
1.
序列:
在python当中,序列就是一组按照顺序排列的值【数据集合】
在python中,存在3种内置的序列类型:字符串,列表,元组
优点:可以支持索引和切片的操作
特征:第一个正索引为0,指向的是左端,第一个索引为负数的时候,指向的是右端。从左往右的。
切片:
【高级特性】可以根据下表来获取序列对象的任意【部分】数据
语法结构:[start:end:step]
!:下标会越界,字符串不会。
上课笔记,记录
# test='python'
# #print(type(test))
# # print('获取第一个字符%s'%test[0])
# for item in test:
# print(item,end=' ')
# name='boy'
# print('姓名首字母大写:%s'%name.capitalize())#capitalize函数可以让首字母大写
# a=' hello '
# b=a.strip()去除字符串中的所有空格
# print(b)
# print(a.lstrip())#lstrip函数删除左边的空格
# print(a.rstrip())#rstrip函数删除右边的空格
#复制字符串
# print('a的内存地址%d'%id(a))#id函数 可以查看一个对象的内存地址
# b=a#在此仅是把a对象的内存地址赋给了b
# print('b的内存地址%d'%id(b))
#
# dataStr='I love you'
# print(dataStr.find('k'))#find函数可以查找目标对象在序列对象中的位置,如果没找到就返回-1
# print(dataStr.index('o'))#index函数检测字符串中是否包含子字符串,是的话返回下标值,找不到对应的数据就会报错。
#
# 判断字符串是以什么开头,什么结尾。正确就是Ture,错误就Flase
# print(dataStr.startswith('I'))
# print(dataStr.endswith('p'))
#
# print(dataStr.lower())#全部转换成小写
# print(dataStr.upper())#全部转换成大写
#
# strMsg='hello world'
# #slice [start:end:step] 左闭右开 start<=value<end 范围
# print(strMsg)#输出完整的数据
# print(strMsg[0])
# print(strMsg[2:5])#2-5下标之间的数据
# print(strMsg[2:])#第3个字符到最后
# print(strMsg[2:7:2])#1-3 strMsg[0:3]=strMsg[:3] 从0开始的话,0可以省略
# print(strMsg[::-1])#倒叙输出 负号表示方向 从右边往左去遍历
list:
python当中非常重要的数据结构,是一种有序的数据集合
特点:
1.支持增删改查
2.列表中的数据是可以变化的【数据项可以变化,内存地址不会改变】
3.用[]来表示列表类型,数据项之间用逗号来分割,注意:数据项可以是任何类型的数据
4.支持索引和切片来进行操作
range() 返回的是一个可迭代对象(类型是对象),而不是列表类型, 所以打印的时候不会打印列表
# li=[]#空列表
# li=[1,2,3,'你好',8]#用逗号分割数据项
# print(len(li))#返回长度
# print(type(li))
# strA='我喜欢python'
# print(len(strA))
#查找
# listA=['abcd',785,12.23,'qiiuzhi',True]
# print(list)#输出完整的列表
# print(list[0])#输出第一个元素,从0开始计算
# print(list[1:3])#前闭后开
# print(list[2:])#从第三个到最后一个
# print(list[::-1])#负数是从右向左开始输出
# print(list*3)#输出多次列表中的数据【复制】
#增加
# print('追加之前',listA)
# listA .append(['fff','ddd'])#追加操作
# listA.append(555)
# print('追加之后',listA)
# listA.insert(1,'这是我刚插入的数据')#插入操作,需要执行一个位置插入,在数据项1后面插入数据
# print(listA)
# rsDate=list(range(10))#list函数,强制转换为list对象
# print(type(rsDate))
# print(listA)
# listA.extend(rsDate)#扩展 等于批量添加
# print(listA)
# listA.extend([11,22,33,44])
# print(listA)
#修改
# print('修改之前',listA)
# listA[0]='peter'
# print('修改之后',listA)
#删除list数据项
listB=list(range(10,15))
print(listB)
# del listB[0]#删除列表中第一个元素
# del listB[1:3]#批量删除多项数据项
# listB.remove(11)#移除指定的元素,参数是具体的数据值
# listB.pop(1)#移除指定的数据项,参数是索引值
print(listB)
print(listB.index(12))#返回的是一个索引下标
list.index(x[, start[, end]])
- x-- 查找的对象。
- start-- 可选,查找的起始位置。(索引值)
- end-- 可选,查找的结束位置。(索引值)
元组:
是一种不可变的序列,在创建之后不能做任何的修改
1.不可变 #不过元组中的列表内的数据是能修改的
2.用()创建元组类型,数据项用逗号来分割
3.可以是任何的类型
4.当元组中只有一个元素时,要加上逗号,不然解释器会当做整形来处理
5.同样可以支持切片操作
#元组
# tupleA=()#空元组
# print(id(tupleA))
# tupleA=('abcd',89,9.12,'peter',[11,22,33])
# print(id(tupleA))
# print(type(tupleA))
# print(tupleA)
#元组的查询
# for item in tupleA:
# print(item,end='')
# print()
# pass
# print(tupleA[2:])
# print(tupleA[::-1])
# print(tupleA[-5:-1])
# print(tupleA[::-2])#表示反转字符串 每隔一个取一次
# print(tupleA[::-3])#表示反转字符串 每隔两个取一次
#
# print(tupleA[-2:-1:])#一样是正着取,不能反着来
# print(tupleA[-5:-1:])
# tupleA[0]='python' #错误的
# tupleA[4][0]=231#可以对元组中的列表类型的数据进行修改
# print(tupleA)
# tupleB=('1',) #当元组中只有一个数据项的时候,必须在第一个数据项后面加上 逗号
# print(type(tupleB))
# print(tupleB)
# tupleC=tuple(range(10))
# print(tupleC)
tupleC=(1,2,3,4,1,2,3,4,4,1)
print(tupleC.count(4))#统计元组中某个数据项出现的次数
字典:
字典是python中的重要的一种数据类型,字典是有 键值对 组成的集合,通常使用键来访问数据,效率非常搞,和list一样 支持对数据的添加,修改,删除。
特点:
1.不是序列类型 没有下标的概念,是无序的键值集合,是python内置的高级数据类型
2.用{}来表示字典对象,每个键值对用逗号分隔
3.键必须是不可变的类型【元组,字符串等】,值可以是任意的类型
4.每个键必定是唯一的,如果存在重复的键,后者会覆盖前者
注意:字典的键(key)不能重复,值(value)可以重复
字典的键(key)只能是不可变类型,如数字,字符串,元组
dictA={"pro":'艺术专业',"school":'北京电影学院'}#空字典
#添加字典数据
dictA['name']='李易峰' #key:value
dictA['age']='30'
dictA['pos']='歌手'
#直接添加
# print(type(dictA))
# print(dictA)#输出完整的字典
# print(len(dictA))#数据项长度 每一项就代表一个键值对
# print(dictA['name'])#通过键获取对应的值
# dictA['name']='谢霆锋' #修改键对应的值
# print(dictA)
# print(dictA.keys()) #获取所有的键
# print(dictA.values()) #获取所有的值
#
# print(dictA.items())#获取所有的键值对
# dictA.update({'age':32}) #更新键值对 也可以添加键值对
# for key,value in dictA.items():
# print('%s==%s'%(key,value))
#删除操作
# del dictA['name']# 通过指定键进行删除
# dictA.pop('age') #通过指定键进行删除
# print(dictA)
#如何排序 按照key来排序
print(sorted(dictA.items(),key=lambda d:d[0]))
#按照value排序
print(sorted(dictA.items(),key=lambda d:d[1]))
整理:
适用于字符串,列表,元组类型的操作有:
1.合并操作+ #两个对象相加操作,会合并两个对象
2.复制*, #对象自身按指定次数进行+操作
适用于字符串,列表,元组,字典类型的操作有:
in判断元素是否存在 #判断指定元素是否存在于对象中
#合并
strA='人生苦短'
strB='我用Python'
listA=list(range(10))
listB=list(range(11,20))
# print(listA+listB)
# print(strA+strB)
tupleA=('abcd',123,6.6)
tupleB=('bcd',124,9.0,[123,22,11])
# print(tupleB+tupleA)
#复制
# print(strB*3)
# print(listB*3)
# print(tupleA*3)
#判断
#in 对象是否存在 结果是一个bool值
print('我' in strB)
print(1 in listB)
print('abcd' in tupleA)
dictA={'name':'peter'}
print('name' in dictA)
print('peter' in dictA['name'])
day4
函数
函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。
函数定义:
def 函数名(参数列表): #0-n个参数
代码块
函数调用:
函数名()
本质上就是去执行函数定义里面的代码块,在调用函数之前,必须先定义
# def printInfo(): # ''' # 这个函数是来介绍小丑的。 # :return: # ''' # #函数代码块 # print('我是%s' % 'hhh') # print('我的年龄%d' % 173) # pass #函数的调用 # printInfo() #函数的调用 # printInfo() #多次调用 # printInfo() #进一步完善这样的需求{输出不同人的信息} 方案:通过传入参数来解决 def printInfo(name,height,age): print('%s的身高%f米' %(name,height)) print('%s的年龄%d岁' %(name,age)) pass #调用带参数的信息 printInfo('小李',1.89,200) printInfo('peter',1.75,160)
参数的分类:必选参数,默认参数【缺省参数】,可选参数,关键字参数
参数:其实就是函数为了实现某项特定的功能,进而为了得到实现功能所需要的外部数据
# #1.必选参数 # def sum(a,b):#形式参数:只是意义上的一种参数,在定义的时候是不占内存地址的 # sum=a+b # print(sum) # #函数的调用 在调用的时候必选参数,必须赋值的 # sum(10,8)#10 8 实际参数:实数,实实在在的参数,是实际占用内存地址的 # #2.默认函数 始终存在于参数列表中的尾部 # def sum1(a=20,b=30): # print('默认参数使用=%d'%(a+b)) # pass # #默认参数调用 # sum1()#输出50 # sum1(10)#输出40 # 在调用时为未赋值,就会用定义函数时给定的默认值 # # 可变参数(当参数的个数不确定时使用,比较灵活) # def getComputer(*args): # ''' # 计算累加和 # :param args:可变长的参数类型 # :return: # ''' # result=0 # for item in args: # result +=item # pass # print(result) # pass # getComputer(1,2,3,4,5,6)
#关键字可变参数 0-n个
# ** 来定义
# 在函数体内 参数关键字是一个字典类型 key是一个字符串
def keyFunc(**kwargs):
print(kwargs)
pass
#调用
# keyFunc(1,2,3) 不可以传递的
dictA={'name':'lei','age':39} #字典
# keyFunc(**dictA) 必须加**
# keyFunc(name='peter',age=26) #键值对 直接传
def complexFunc(*args,**kwargs):#前面是元组,后面是字典
print(args)
print(kwargs)
pass
# complexFunc(1,2,3,4,name='lll')
complexFunc(age=29)
def TestMup(**kwargs,*arges): #不符合要求的
'''
可选参数必须放到关键字可选参数前
可选参数:接受的数据是一个元组类型
关键字可选参数:接受的数据是一个字段类型
:param kwargs:
:param arges:
:return:
'''
pass
函数返回值:
概念:函数执行完以后会返回一个对象,如果在函数的内部有return就可以返回实际的值,否则返回None
类型:可以返回任意类型,返回值类型一个取决于return后面的类型
用途:给调用方返回数据
在一个函数体内可以出现多个return值,但是肯定只能返回一个return
如果在一个函数体内,执行力return,意味着函数就推出了,return后面的代码语句就不会执行。
# def Sum(a,b):
# sum=a+b
# return sum#将计算结果返回
# pass
# t=Sum(10,30)
# print(t)
# print(Sum(10,30))#函数的返回值返回到调用的地方
def c(num):
li=[]
result=0
i=1
while i<=num:
result+=i
i+=1
pass
li.append(result)
return li
pass
# 调用函数
value=c(100)
print(type(value))
print(value)
def divid(a,b):
shang=a/b
yushu=a%b
return shang,yushu #多个返回值用逗号分隔
sh,yu = divid(5,2) #需要使用多个值来保存返回内容
print('商:%d,余数:%d'%(sh,yu))
#全局变量和局部变量
def test1():
a=300#局部变量:在一个函数里面定义的变量
print('test1---修改前:a=%d' % a)
a=100
print('test1---修改后:a=%d' % a)
pass
def test2():
a=500
print('test2---a=%d'%a)
pass
test2()
test1()
'''
a=100 #全局变量
def test1():
global a #声明全局变量在函数中的标识符
print(a)
a = 200 #全局变量已经修改
print(a)
pass
def test2():
print(a)
pass
test2()
test1()
'''
day5:文件操作
文件写入
f =open('test.txt','w')
# 打开文件,w模式(写模式)
f.write('hello,my world')
f.close()
# 关闭文件
文件读取
f = open('test.txt','r')
# 读取指定字符,开始时定位在文件头部,每执行一次向后移动指定字符数
content = f.read(5)
print(content)
# 读取前几个字符
content=f.read(5)
print(content)
# 空格也会读取
f.close()
f=open('test.txt','r')
content=f.readlines()
# 一次性读取全部文件为列表,每行一个字符串元素
print(content)
# i=1
'''
读取多行
'''
# for temp in content:
# print('%d:%s'%(i,temp))
# i+=1
f.close()
f=open('test.txt','r')
content=f.readline()
print('1:%s'%content)
'''
读取一行
'''
content=f.readline()
print('2:%s'%content)
f.close()
day6:异常处理
# 捕获异常
try:
print('----------------test1-------------------------')
f=open('123.txt','r')
#打开一个不存在的文件 FileNotFoundError
print('------------test2------------------')
except IOError:
# 文件没找到,属于IO异常(输入输出异常)
pass
# 捕获异常后执行的代码
# 捕获异常
try:
print('----------------test1-------------------------')
f=open('123.txt','r')
#打开一个不存在的文件 FileNotFoundError
print('------------test2------------------')
print(num)
except (NameError,IOError):
#将可能产生的异常放到括号内
print('产生错误了')
# 捕获所有异常
try:
print('----------------test1-------------------------')
f=open('test.txt','r')
# test.txt存在,123.txt不存在
#打开一个不存在的文件 FileNotFoundError
print('------------test2------------------')
print(num)
except Exception as result:
# 打印异常情况
# Exception可以捕获所有异常
print('产生错误了')
print(result)
#try。。。finally 和嵌套
import time
try:
f=open('123.txt','r')
try:
while true:
content = f.readline()
if len(content)==0:
break
time.sleep(2)
print(content)
finally:
f.close()
print('文件关闭')
except Exception as result:
print('发生异常。。。')
#try。。。finally 和嵌套
import time
try:
f=open('test.txt','r')
try:
while True:
content = f.readline()
if len(content)==0:
break
time.sleep(2)
print(content)
finally:
f.close()
print('文件关闭')
except Exception as result:
print('发生异常。。。')
# 写古诗
f = open("gushi.txt", "w", encoding="utf-8")
#创建gushi.txt,并以写入的模式打开
f.write("""
静夜思
李白
床前明月光,疑是地上霜。
举头望明月,低头思故乡。""")
#写入古诗
f.close()
# 复制
f = open("gushi.txt", "r", encoding="utf-8")
m = open("copy.txt", "w", encoding="utf-8")
#以只读模式打开guishi.txt,创建copy.txt,并以写入模式打开
content = f.readlines()
#读取gushi.txt中的所有行
for i in content:
m.write(i)
#将读取到的每行内容依行写入copy.txt
f.close()
m.close()
f=open('shi.txt','w',encoding='utf-8')
f.write('''《一剪梅·雨打梨花深闭门》
雨打梨花深闭门,孤负青春,虚负青春。
赏心乐事共谁论?花下销魂,月下销魂。
愁聚眉峰尽日颦,千点啼痕,万点啼痕。
晓看天色暮看云,行也思君,坐也思君。''')
f.close()
f=open('shi.txt','r',encoding='utf-8')
m=open('chao.txt','w',encoding='utf-8')
content=f.readlines()
for i in content:
m.write(i)
f.close()
m.close()