Python笔记

一、基础

print

print里面可以加单引号、双引号、三引号以及不带引号

Python是解释型语言，在运行的时候，解释器将程序翻译成机器语言。

• 不带引号，打印数字

 print(1234)

• 其中，单引号和双引号的效果是一样的。 有时，句子内有单引号，所以，就用双引号将句子包含起来，防止歧义。也即，双引号可以输出内容中的单引号。更好一些。

 print("Let's go!")

#是注释

Python对于分号;，可以加，也可以不加。加上，就能在一行内写多个语句了。

if语句内的()可加可不加 if (a==0): if a==0 :

• 在 print()函数中使用三引号'''实现跨行输出

 print('''哪吒
 托塔李天王家的三太子
 变化三头六臂又或三头八臂
 百邪不侵专克摄魂夺魄的莲花化身''')  

命名规范：

1. 只能包含数字、字母和下划线

2. 不能以数字开头

3. 尽量描述包含的数据内容

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,4

for 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……except

try:
	#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('我在唱歌')

注意，类名称的首字母要大写。类中的成为方法，类外的成为函数。

1. 与类和实例无绑定关系的function都属于函数（function）；

2. 与类和实例有绑定关系的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__方法

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()

enter_1625

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,Z

from...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,strtest

if __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')