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=0i=1while i<=num:result+=ii+=1passli.append(result)return lipass# 调用函数
value=c(100)
print(type(value))
print(value)def divid(a,b):shang=a/byushu=a%breturn shang,yushu   #多个返回值用逗号分隔
sh,yu = divid(5,2)       #需要使用多个值来保存返回内容
print('商：%d，余数：%d'%(sh,yu))#全局变量和局部变量
def test1():a=300#局部变量:在一个函数里面定义的变量print('test1---修改前：a=%d' % a)a=100print('test1---修改后：a=%d' % a)passdef test2():a=500print('test2---a=%d'%a)passtest2()
test1()'''
a=100           #全局变量
def test1():global a    #声明全局变量在函数中的标识符print(a)a = 200     #全局变量已经修改print(a)passdef test2():print(a)passtest2()
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')#打开一个不存在的文件 FileNotFoundErrorprint('------------test2------------------')
except IOError:# 文件没找到，属于IO异常（输入输出异常)pass# 捕获异常后执行的代码

# 捕获异常
try:print('----------------test1-------------------------')f=open('123.txt','r')#打开一个不存在的文件 FileNotFoundErrorprint('------------test2------------------')print(num)
except (NameError,IOError):
#将可能产生的异常放到括号内print('产生错误了')

# 捕获所有异常
try:print('----------------test1-------------------------')f=open('test.txt','r')# test.txt存在，123.txt不存在#打开一个不存在的文件 FileNotFoundErrorprint('------------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:breaktime.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:breaktime.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()

python求知讲堂-wms学习笔记相关推荐

36篇博文带你学完opencv :python+opencv进阶版学习笔记目录
基础版学习笔记传送门 36篇博文带你学完opencv :python3+opencv学习笔记汇总目录(基础版) 进阶版笔记项目 opencv进阶学习笔记1: 调用摄像头用法大全(打开摄像头,打开摄像 ...
Python中索引的学习笔记
1 前言今天在学习FaceBoxes- 看到一个比较奇怪的代码,"order = scores.argsort()[::-1][:args.top_k]",不太懂这个" ...
Python地理做图——学习笔记
Python地理做图--学习笔记 GMT 绘制海岸线绘制地形并叠加海岸线地理信息数据格式在线转换网址适用OSGEO4w可以实现tif转nc,转grd 绘制grd和nc 除了投影方式-X, gmt ...
基于python的数字图像处理--学习笔记（三）
基于python的数字图像处理--学习笔记(三) 前言一.灰度拉伸二.幂律(伽马)变换三.对数变换前言进入冈萨雷斯的第三章内容,并用python实现功能.我更改了代码源,之前找到太烂了,代码 ...
Python第三方库pygame学习笔记(一)
Pygame Python最经典的2D游戏开发第三方库,也支持3D游戏开发 Pygame适合用于游戏逻辑验证.游戏入门及系统演示验证 Pygame是一种游戏开发引擎,基本逻辑具有参考价值 pygame ...
python气象数据可视化学习笔记6——利用python地图库cnmaps绘制地图填色图并白化
文章目录 1. 效果图 2. cnmaps简介及安装 2.1 写在前面 2.2 cnmaps简介和安装 3. 导入库 4. 定义绘图函数 4.1 使用get_adm_maps返回地图边界 4.2 ax ...
Python快速编程入门#学习笔记01# |第一章：Python基础知识（Python发展历程、常见的开发工具、import模块导入）
全文目录 ==先导知识== 1 认识Python 1.1.1 Python的发展历程 1.1.2 Python语言的特点 2. Python解释器的安装与Python程序运行 1.2.1 安装Pyth ...
Python+cplex运筹优化学习笔记（三）-营养膳食选择
Python+cplex运筹优化学习笔记(三)-营养膳食选择前言首先呢,说明一下,本文只是自己在学习过程中运用到的例子,然后规整总结一下,随便写写自己所做的一些笔记.小白学习,有不对的地方还望大家 ...
全国计算机等级考试二级Python精品题库学习笔记1
全国计算机等级考试二级Python精品题库学习笔记1 精品试卷01 精品试卷01程序题基本操作题 2:随机验证码基本操作题 3:比赛成绩计算 Turtle 绘图题:同心圆简单应用题 2:员工工资 ...

python求知讲堂-wms学习笔记