【机器学习】Python 快速入门笔记
Python 快速入门笔记
Xu An 2018-3-7
1、Python print
#在python3.X中使用print（）进行输出，而2.x中使用（）会报错
print("hello world")
print('I\'m apple') #如果全部使用单引号，则需要在前面加上转义字符\+引号
print('apple'+'pear')
print('apple'+str(4)) #将数字转换为字符串并打印
print(int("1")+2)#将字符串转换为整数类型2、pyhton数值运算
print(2**2) #幂运算为**
print(10%3) #取余数为%
print(9//4) #取整数为//3、自变量定义
a,b,c=1,2,3 #一次定义多个变量
print(a,b,c)4、while循环
condition=1
while condition<10:
print(condition)
condition+=15、for循环（相当于迭代器）
x=1
y=2
z=3
if x<y<z:
print("x is less than y")6、if-else语句
if x<y:
print("x<y")
else:
print("x>y")7、if-elif-else
if x<y:
print("x<y")
elif x==y:
print("")
else:
print("x>y")8、函数定义
def add(a,b): #在python中定义函数需要使用def（）
c=a+b
print("This is the result of the addtion:",c)
add(1,3)9、默认函数参数
def car(price,color='red',second_hand=True):
#在函数参数后面加=“默认值”可以完成默认值的赋值
#bool类型中的参数需要大写True、Flase
#需要把默认参数放到变量的后面
print('price',price,
'color',color,
'second_hand',second_hand,
)
car(1000)10、变量类型
'''
（1）全局变量
在模块内、所有函数外、class外的变量，可以被全局共享，也可以被外部文件共享
全局变量使用时，需要使用global显式声明
如果不将全局变量更新，一般不需要加global声明
如果有重新赋值，又没有在函数内部使用global声明时，相当于在内部创建了一个同名的局部变量
同名局部变量优先级高于未显式声明的全局变量
'''
APPLE=10 #全局变量需要在函数外部定义
def test10_01():
global APPLE #在函数内部定义全局变量
APPLE=20 #在函数内声明的局部变量的优先级高于全局变量
print(APPLE)
test10_01()'''
(2)局部变量
在函数内、class方法内（未加self修饰）
生命周期在函数执行时，当函数执行完毕后局部变量消亡
'''
def test10_02():
city='shijiazhuang'
print(city)'''
(3)静态变量（类变量）
通过类名直接访问，也可以通过实例名直接访问，变量在类中、实例间全局共享
'''
# class foo:
# all=0
# def add(self):
# foo.q+=1
# ins_1=foo() #实例化对象1
# ins_2=foo() #实例化对象2
# print(ins_1.all) #0
# print(ins_2.all) #0
# print(foo.all) #0
# ins_1.add() #静态全局变量加1'''
(4)实例变量
对于模块来说，拥有自己的全局变量，可以供自己内部的类，函数使用
对于类或者方法来说，有自己的局部变量，供自己内部使用
对于类，有了静态变量，可以供内部和有继承关系的父子使用
实例间各自的局部变量需要靠动态绑定多态实现
'''
class foo_1:
all=0
def __init__(self,name):
self.name=name
def add(self):
foo.q+=1'''
(5)总结
私有变量:自己独享的变量，如函数和方法的局部变量，实例变量
公有变量:需要在一定范围内共享，达到同步的目的，如模块内的代码共享的全局变量，类与子类之间共享的静态变量
'''
11、文件写入
text="This is my first text.\nThis is next line\n" #使用\n表示换行,主要换行指令与c++一致
print(text)
my_file=open('1.txt','w')
#open可以打开一个文件，open（‘文件路径’，‘形式’），形式w为可写形式，r为只读形式
my_file.write(text) #在文件中写入相应的语句
my_file.close() #切记在文件写入后要使用close方法关闭文件
print('Flie writing completed.')12、文字内容追加
my_file=open('1.txt','a') #方式a是append的缩写，表示文件的追加模式
append_text="this is appened text"
my_file.write(append_text)
my_file.close()# 13、读文件
my_file=open('1.txt','r') #r为读模式
content=my_file.read() #读取文件内容需要使用read（）方法
second_read=my_file.readline()
third_read=my_file.readline() #readline为逐行输出文字
all_read=my_file.readlines() #逐行读取后会将读取的元素按行放置在一个列表中
print(content,'second_read',second_read,'third_read',third_read,'all_read',all_read)14、类（class）
class Calculator: #类一般为大写
def __init__(self,name,price): #构造函数，在进行对象实例化时必须赋值,前面需要加上self
self.name=name
self.price=price
name="Calculator"
price=10
def add(self,x,y):
print(self.name) #如果要在类内调用本身的方法，需要加上self.属性名或self.方法名
result=x+y
print(result)
def minus(self,x,y):
result=x-y
print(result)
def times(self,x,y):
result=x*y
print(result)
def devide(self,x,y):
result=x/y
print(result)
newcalulator=Calculator('name',10)
print(newcalulator.name)15、input
a_input=input('Please give me a number:') #input的功能为输入，其后面的括号为提示信息，input的返回值为输入的内容(是str类型)，并赋值给对应的参数
int_input=int(a_input) #对字符串需要转换为int类型后进行判断
if int_input==1:
print('your input is 1')
elif int_input==2:
print('your input is 2')
else:
print('your input number is other')16、元组 使用小括号或者不使用括号
a_tuple=(1,2,3,43) #元组可以用小括号的形式，也可以不加小括号
another_tuple=1,12,43,23
for x in a_tuple:
print(x)17、列表 使用中括号
a_list=[12,34,23,43]
for x in a_list: #将list的值使用for循环放到x中，之后打印出来
print(x)
for index in range(len(a_list)): #range()会生成一个迭代器，index为索引
print("index=",index,'number in list=',a_list[index])
a=[1,2,3,4,5]
a.append(0) #在列表后面追加一个元素
print(a)
a.insert(1,0) #insert(添加位置，数值)
a.remove(2) #remove(第一次出现的数值)
print(a[3:5])
a.index(1)#列表中第一次出现该数值的索引
a.sort(reverse=True) #默认为从小到大进行排序，加入reverse则进行从大到小进行排序
print(a)18、多维列表
a=[1,2,3,4,5]
multi_dim_a=[[1,2,3],[123,312,4],[12,43,1]]
print(multi_dim_a[1][1]) #使用[][]进行索引19、字典 使用大括号
d={'apple':1,'pear':2,'orange':3} #冒号前面的为key，后面的为内容，字典的key唯一，如果不唯一则记住后面的元素，其不能是列表，以保证其唯一性要求
print(d['apple']) #打印字典的值
del d['pear'] #从字典中删除元素
d['b']=20 #加入元素到字典
print(d) #因为字典采用hash存储，所以字典是一个无序的容器20、import模块
#方法一：
# import time #直接使用模块名进行后续操作
# print(time.localtime())
# 方法二：
# import time as t #如果模块名太长可以使用简称
#方法三：
# from time import localtime 只引入模块的某个功能
# print(localtime()) #如果使用本方法，可以不用写time.localtime,而直接写localtime()
#方法四：
from time import * #加*可以结束
print(localtime())21、引入自己的模块
# 确保自己的模块（同为.py文件）和本文件在同一个目录下，
# import m1 #自己的模块名，其中定义了函数
# m1.function() 直接调用其函数即可，在Macox中，其包目录在site-package中，如果将自建模块放入其中，则可以直接调用22、break&continue
a=True
while a:
b=input('Please enter something:')
if b!='':
print('enter is not blank')
break23、错误处理
try:
File=open('12','r')
except Exception as e:
print('there is no file named 12')
response=input('do you want to creat a new file?(Y/N)')
if response =='y'or'Y': #逻辑运算符 或or 且and 非not
print('the file is created')
else:
pass #跳过24、zip（将两个列表合并为一个列表项） lambda map
a=[1,2,3]
b=[4,5,6]
list(zip(a,b)) #zip返回为一个对象，如果想将其可视化，需要将其转化为list进行合并
for i,j in zip(a,b):
print(i/2,j/2) #生成一个迭代器进行输出
fun1=lambda x,y:print(x+y)
fun1(2,3)
def fun1(x,y):
return(x+y)
#实现参数绑定
print(fun1,[1,3],[2,8])25、shallow copy &deep copy
import copy
a=[1,2,3]
b=a
print(id(a)) #输出变量的唯一id，是赋值，b只是将a的地址进行了复制，而没有进行实际的变量值的拷贝
print(id(b))
c=copy.copy(a)
print('id of a:',id(a))
print('id of c:',id(c)) #浅拷贝，id不同，第一层空间地址不同，但是第二层空间（数组第二围）开始地址相同
d=copy.deepcopy(a)
print('id of a:',id(a))
print('id of c:',id(d)) #深拷贝，id不同，从第一层空间开始地址已经完全不同# 26、threading 线程
# 27、multiprocessing 多核心
# 28、tkinter GUI界面
29、pickle 保存代码
import pickle
# a_dic={'fruit':['apple','pear'],'vegetable':['tomato','cumcuber']}
# file =open('pickle_exm.pickle','wb')
# pickle.dump(a_dic,file)
# file.close()
# file=open('pickle_exm.pickle','rb')
# a_dic=pickle.load(file) #将之前保存的代码打开
# file.close()#或者自动关闭方案
with open('pickle_exm.pickle','rb') as file:
a_dic=pickle.load(file)30、使用set寻找不同
char_list=['a','b','c','c']
print(set(char_list)) #使用set进行不同查找，输出结果为非重复序列，按hash排序
sentence='welcome to shijiazhuang'
print(set(sentence)) #可以分辨句子中的不同字母，并以单个的形式呈现# 31、正则表达式（待补充）
import re #引入正则表达式
pattern1="cat"
pattern2='dog'
string="dog runs to cat"
print(pattern1 in string) #使用in来判断单词是否在目标语句中
#查找
print(re.search(pattern1,string))#使用正则表达式进行查找，查找到的内容会被以对象的形式返回
#匹配多种可能——使用[]
print(re.search(r"r[A-Z0-9]n",'dog runs to the cat'))相关文章