Python笔记
一、基础
print
print里面可以加单引号、双引号、三引号以及不带引号
Python是解释型语言，在运行的时候，解释器将程序翻译成机器语言。
不带引号，打印数字
print(1234)其中，单引号和双引号的效果是一样的。 有时，句子内有单引号，所以，就用双引号将句子包含起来，防止歧义。也即，双引号可以输出内容中的单引号。更好一些。
print("Let's go!")#是注释
Python对于分号;，可以加，也可以不加。加上，就能在一行内写多个语句了。
if语句内的()可加可不加 if (a==0): if a==0 :
在 print()函数中使用三引号
'''实现跨行输出
print('''哪吒
托塔李天王家的三太子
变化三头六臂又或三头八臂
百邪不侵专克摄魂夺魄的莲花化身''') 
命名规范：
只能包含数字、字母和下划线
不能以数字开头
尽量描述包含的数据内容
print如何输出不换行：
print("wow",end=" ")
结尾字符为空格。print输出换行：
print("")
或者print('')String
word = '''we
love
you'''
可以这样赋值，三引号实现跨行赋值。字符串拼接
print(str1+str2+str3)
查看变量类型
print(type(name))
数据转换的三个函数
str()
int()
float()
str = "1"
print(int(str))
如果str不是整数，比如是 "1.1"，(文字类和小数类字符串)那么使用int("1.1")就会报错
但是可以 int(1.1)-->1
float('30.0') import time
time.sleep(2)程序停顿两秒if
if op1:
#
elif op2:
#
else:
#input
input("这里是输入提示语句：")
input的输出默认不换行，可以加上'\n'来换行input()输入的值，会被强制性的转换为字符串类型。
所以读取整数，应该：num = int(input())
List列表
list = ['李雷','韩梅梅',180,3.5]
print(list)
print(list[:]) ---> 等价print(list)
print(list[2:]) ---> [180, 3,5]
print(list[:2]) ---> ['李雷', '韩梅梅']
print(list[1:3]) ---> ['韩梅梅', 180]
遵循左闭右开的原则，从零开始
冒号左边为空，表示从零取；冒号右边为空，表示取到最后一个
这样通过冒号来截取列表元素的操作叫切片，
就是将列表的某个片段，通过切割下标的方式来提取多个元素添加元素 list.append("something")
通过元素下标删除元素
del list[2]
del(list[2])
列表长度：
print(len(list))
字典
dic = { '擎天柱': 95 ,'大黄蜂':90 ,'救护车':86, '巨无霸福特':80,'红蜘蛛':80 }
取值：print(dic['擎天柱'])
输出: print(dic)
删除元素：del dic['擎天柱']
增加元素：dic['name'] = 100长度 print(len(dic))
遍历字典：
for i in {1:"A", 2:"B"}什么时候用列表，什么时候用字典？
当数据需要依次放好的时候，需要使用列表
当数据需要打上标签放好的时候用字典
for
for i in [1,2,3,4,5,6]:
print(str[i]+"something")
for i in list:
#
for i in "郭哲":
#
其中i是不用提前定义的。
但是for循环执行完毕后，i保存了list最后一个元素对于字典：
dic = ["one":1, "two":2, "three":3]
for item in dic:
print(item)
#奇妙的是可以这样做
print(dic[item]) #得到 1，2，3
则输出的是one two three，即字典的每一个键range()函数
左闭右开
for i in range(5):
print(i)
则，输出 0,1,2,3,4
for i in range(1,5):
print(i)
则，输出1,2,3,4for i in range(0,100,11):
print(i)
这里range(0,100,11) 的意思：从0到99（n-1）依次取数， 数与数之间的间隔为11。while
a = 0
while a <5:
a = a+1
print(a)布尔运算：False True
默认为False的为：
False、0、''(空串)、[]、{}、None布尔运算有5种运算：
and, or, not, in, not in
and是与，or是或
not True 为假，not False为真
in:
list = [1,2,3]
a = 1
b = 10
print(bool(a in list)) ---> True
print(bool(b not in list)) ---> True循环内语句
break, continue, pass, else
pass：
if something:
pass #即什么也不做 else:
for i in range(3):
#
else:
print("结束")
else后面的只执行一次。
一句话总结，当循环中没有碰到break语句，就会执行循环后面的else语句，否则就不会执行。函数
函数是组织好的，可以重复使用的、用来实现单一功能的代码
一个长度函数
len("我是字符串")
len(['KFC', 'MC'])定义函数的语法：
函数名的命名规则同变量
def 函数名(参数):
函数体
return 语句
---------------
def func(x):
y = 6*x+9
return y函数也可以没有参数和返回值：
def hello():
print("hello world!")
hello()可以有默认参数，它在位置参数后面：
def menu(hambuger,drink,snacks="蛋挞"):
print("我要吃%s, %s, %s" %(hambuger,drink,snacks))
menu("鸡腿堡","可乐")
menu("鸡腿堡","可乐","薯条")不定长参数：
def menu(*food):
return food
order = menu("烤肠","鸡腿")
print(order) ---> ('烤肠', '鸡腿')
print(type(order)) --> <class 'tuple'>
tuple 称作元组，元组种的元素不可更改。使用小括号包裹
元组亦可以通过for循环遍历
for i in order:
print(i)print()函数
print(*objects, sep = ' ', end = '\n', file = sys.stdout, flush = False)多个返回值：
设计知识点：
random.choice(list) --> 从列表种随机选一个元素
return a, '冰激凌' --->返回值是Tuple，(a, '冰激淋')
import random
foodten = ['蛋挞','鸡翅','薯条']
def order(money):
if money > 99:
a = random.choice(foodten)
return a,'冰激淋'
elif 69 < money < 99:
b = random.choice (foodten)
return b
else:
return '不好意思，您的消费达不到优惠活动'
print(order(50))
print(order(70))
print(order(130))作用域：
全局作用域：在所有函数之外赋值的变量，可以在程序任意位置使用（全局作用域），这就是全局变量
局部作用域：在某个函数内部赋值的变量，只能在当前函数内使用(局部作用域),出了这个函数，它就不起作用了，这就是局部变量
如果让某个函数内的变量可以在其他函数使用，可以加个global修饰：
def KFC():
global harland
return
def McDonald():
print("%s" %harland)
return 可以通过不同赋值，来实现同一个函数不同参数：
def function(a=0,b=1,c=2):
return a + b + c
print(function(c=3, b=1))
在参数列表，写上参数名=参数值，另外，可以不按照顺序赋值。
如果参数没有初始值，则必须进行赋值。
也可以这样print(function(1, b=2))，这样就是a = 1,b=2。不含参数名称的从左到右赋值。
另外，还可以令参数初始值为None
def func(a = None):
if a == None:
return True
else:
return False
那么a既可以赋值，也可以不赋值。进而进行其他判断操作。错误：
import math
print(2.2*100/20) ---> 11.00000000002
print(math.ceil(2.2*100/20)) ---> 12这样，本来结果是11，然而得到了12。
所以我们为了保险，应该使用round()函数
print(round(2.2*100/20,2))
意思是保留2位小数注意
def func( a ):
if a > 0:
return a
b = func(-1)
那么由于func没有返回值，b就得到了None，否则得到a的值。异常捕获
while True:
try:
age = int(input("输入年龄：\n"))
break
except ValueError:
print("您输入的不是数字，请重新输入")
try……excepttry:
#dosomething
except:
# do
else:
# do
except捕获异常，可以不写哪种异常，直接捕获
else，可以在运行成功时进行运行。知识补充
time
Random
import random #导入模块
num = random.randint(1,2)
print(num)
范围是 1 - 2，两边都取格式化字符串
%s 字符串含义
%f 浮点数显示
%d 整数显示。
a = 1.2
print("%f %s %d" %(a,a,a))
输出为：1.200000 1.2 1
单个数据可以不加括号
a = 1.2
print("%f"%a)
print("%.1f" %a)表示保留一位小数Math
import math
math.ceil(1.4) -->2数字计算：
print(2/3)
默认转换为浮点型取模计算：
print(2.3%1)
得到：0.2999999999999998
所以Python的取模运算，可以计算浮点数。
同时使用 num % 1 == 0 ? 来判断是否为整数二、面向对象
print(type('666')) # <class'str'>
print(type(6666)) # <class'int'>
print(type([6666])) #<class'list'>例子：
class Musician:
loveMusic = True
def sing(self):
print('我在唱歌')注意，类名称的首字母要大写。类中的成为方法，类外的成为函数。
与类和实例无绑定关系的function都属于函数（function）；
与类和实例有绑定关系的function都属于方法（method）。
类的实例化：
Future = Musician()
使用`.`进行调用其属性和方法。
print(Future) ---> <__main__.Musician object at 0x00000251FF1C8C40>
print(type(Future)) ---> <class '__main__.Musician'>self参数
作用：self会在类的实例化中接收传入的数据， 在代码中运行。
class Musician:
name = '羽泉'
def sing(self):
print(self.name+'是音乐人')
singer = Musician()
print(singer.name)
singer.sing()它的作用就是先在类方法中占一个位置，当实例创建调用类方法的时候，它就会将self.name也就是类中的name放入方法中，也就会把’羽泉’放入方法中。
而我们无需给self参数赋值。
如果要有多个参数，可以：
class Demo:
def sing(self,otherParameter):
print("")
传参只要串同时self参数也可以调用本类的其他方法。
初始化方法
class Demo:
def __init__(self):
self.glass = "黑墨镜"
self.microphone = "iphone"
在无参的初始化方法中，实例化时直接无参即可。
demo = Demo()
对于有参初始化方法：
class Demo:
def __init__(self,glass,microphone):
self.galss = glass
self.microphone = microphone
demo = Demo("墨镜","iphone")另外，类的属性不需要声明，只要在初始化方法里面赋值即可。
class Demo:
def __init__(self,property):
self.property = property
这样，类Demo就有property这个属性了。类的继承
class Father:
def sing(self):
print("我在唱歌")
class Son(Father):
pass当没有括号时，此类的父类就是Object。即根类。
isinstance()来判断一下某个实例是否属于某个类
isinstance(obj, object) True，所有类创建的实例都属于根类object
子类创建的实例也属于父亲
父亲创建的实例不属于子类多层继承
多重继承
class Z(X,Y):
pass
括号内的父类是由顺序区别的，与Z子类更接近的父类放在左边。
当X，Y类的属性和方法重复时，优先使用左边的父类的属性和方法类的定制
class Musician():
loveMusic = True
def intr(self):
print("我喜欢音乐")
print("我来自音乐界")
def sing(self):
print("我在唱歌")
# Rapper继承音乐人
class Rapper(Musician): #类的继承
garrulous = True #类的定制 ， 增加属性
def composition(self): #类的定制， 增加方法
print("我可以创作简单的歌词")
def sing(self): #改写方法 ，覆盖重写
print("我用说唱的方法唱歌")__str__方法
__str__方法class Bike:
def __init__(self,NO,age,state=0):
self.NO = NO
self.age = age
self.state = state
def __str__ (self):
if self.state == 0:
status = '待租借'
else:
status = '租借中'
return '车辆编号%d 已经运行%d年，车辆状态：%s' %(self.NO,self.age,status)
bike = Bike(1001,2)
print(bike)此时，直接print bike对象，显示的内容是__str__方法的返回值。
三、解码与编码
编码
print('开课吧'.encode('gbk')) # 编码
# out:b'\xbf\xaa\xbf\xce\xb0\xc9'
print('开课吧'.encode('utf-8'))
# out:b'\xe5\xbc\x80\xe8\xaf\xbe\xe5\x90\xa7'
print(b'\xbf\xaa\xbf\xce\xb0\xc9'.decode('gbk')) # 译码
# out:开课吧
print(b'\xe5\xbc\x80\xe8\xaf\xbe\xe5\x90\xa7'.decode('utf-8'))
# out:开课吧最前面都有一个字母‘b’，这是代表它是bytes(字节)类型的数据。
print(type('开课吧'))
# <class 'bytes'>
print(type(b'\xbf\xaa\xbf\xce\xb0\xc9'))
# <class 'bytes'>
print(type(b'\xe5\xbc\x80\xe8\xaf\xbe\xe5\x90\xa7'))
# <class 'bytes'>文件读取和写入
文件读取
myFile = open(r'test.txt', 'r')
.py文件和.txt文件需要在一个文件夹内
第一个r是读取文件的固定符号，最后一个'r'是文件打开模式
'r'代表read，文件读取的意思。myFileContent = myFile.read()
使用read函数，读取myfile变量中的文件的数据print(myFileContent)
myFile.close()文件写入
文件的写入'w'，会直接情况原文件的内容。
如果要不清空原来的内容，可以采取'a'模式，意思为追加append
myFile = open(r'test1.txt','w')
myFile.write('从你的全世界路过')
myFile.close()
with open(r'test.txt','a') as myfile:
myfile.write('你好')
with方法，自动在我们读写结束后，关闭文件。四、模块
回顾：
函数，是组织好的，可以重复使用的，用来实现单一功能的代码
类，封装了属性和方法，实现了更多功能
模块:模块是最高级别的程序组织单元，它将程序代码和数据封装起来以便重用。也就是模块可以封装任何数据、代码。
引入自己的模块
创建两个文件：main.py mytest.py
在main.py内，写下：
import mytest
如果mytest.py里面由输出语句，则立即执行。比如导入 import myTest
我们就可以使用myTest里面的变量，函数和类
如 myTest.property
myTest.func()
obj = myTest.Classes()
obj.method()
另一种用法import...as...
import myTest as ts
仅是将myTest替换为ts。同时导入多个模块：
import X,Y,Zfrom...import
#mytest模块
strtest = '驭风少年'
def hello():
intro = "你好,我是驭风少年函数"
print("hello函数正在运行")
#main.py
from mytest import hello
from mytest import strtest
hello()
print(strtest)
或者 from mytest import hello,strtestif __name__ == '__main__'
a.py:
A语句
if __name__ == '__main__':
B语句
当a.py直接被运行时，代码块B被运行
当a.py作为模块是被其他程序导入时，只会运行代码块A，代码块B不执行
我测试了一下，a.py直接运行时，__name__的值为 '__main__'
而，被其他程序导入时：print(a.__name__)得到了 'main'导入自带模块
import time
time.sleep(3) # 3秒
import random
print(random.randint(1,3)) 闭区间time模块的作用列表
import time; # 引入time模块
ticks = time.time() #时间戳 每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。
print ("当前时间戳为:", ticks)
localtime = time.localtime(time.time()) #本地时间 从返回浮点数的时间戳方式向时间元组转换，只要将浮点数传递给如localtime之类的函数。
print ("本地时间为 :", localtime)
localtime = time.asctime( time.localtime(time.time()) ) #根据需求选取时间格式
print ("本地时间为 :", localtime)
print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) )# 格式化成2016-03-20 11:45:39形式
print (time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()) )# 格式化成Sat Mar 28 22:24:24 2016形式
a = "Sat Mar 28 22:24:24 2016"
print (time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y")))# 将格式字符串转换为时间戳CSV模块
csv模块时一个处理excel表格的模块
需要让Excel表格保存格式为 *.csv
读入csv
import csv
with open("mytest.csv",encoding='utf-8-sig') as r:
print("内容如下\n")
reader = csv.reader(r)
#r就是那个csv文件
#使用csv的reader()方法，创建一个reader对象
for content in reader:
#遍历reader对象的每一行
print(content)
得到：
['11', '12', '13']
['21', '22', '23']
['31', '32', '33']写入csv
import csv
with open("mytest1.csv",'a') as r:
writer = csv.writer(r)
writer.writerow([41,42,43])
print("写入完毕！")
#writer是实例化对象，writerow()是写入的方法,括号内的数据是列表形式。另一种：
with open("detaillist.csv", "a", newline='', encoding='GBK') as listfile:
writer = csv.writer(listfile, dialect='excel')最后更新于
这有帮助吗？