【机器学习】基础篇 -- Python编程从入门到实践语法篇笔记

变量与数据类型

字符串

• 单引号’ '或者双引号" "
• 字符串使用变量

使用f字符串

first_name = "ada"
last_name = "love"
full_name = f"{
      
      first_name} {
      
      last_name}"
print(full_name.title())

数

3 ** 2     #乘方，结果是9

强制类型转换

str(age)         # 转变为字符串
int(age)         # 转变为整型

列表

list = ['trek','cannondale','redline','specialized']

读 增删

list[-1]
#表示最后一个元素
list[-1]
#列表的增删
list.append('honda')     #在列表末尾添加字符串'honda'
list.insert(0,'ducati')  #在第一位插入字符串'ducati',后面的元素后移一位
del list[0]              #删除第一个元素
str = list.pop()         #删除列表末尾的元素，同时可以把这个元素赋值给另一个变量
str = list.pop(0)        #删除指定索引元素
list.remove('ducati')    #不清楚元素位置，知道元素值

排列

#列表的排列（排列时列表数据类型要保持一致）
list.sort()              #按字母顺序排列列表
list.sort(reverse = True)#按与字母顺序相反的顺序排列列表
sorted(list)             #不影响原有列表的排列顺序，直接返回一个排列好的列表
sorted(list,reverse = True)   #反向排列，不改变原有列表
list.reverse()           #将列表元素反转排列

随机数

range(1,5)               #1到4的整数，是可迭代对象
range(2,11,2)            #2到10的整数，步长为2（2，4，6，8，10）
list(range(1,5))         #转换为列表

最大最小值等

min(list_digits)         #找出数字列表的最小值
max(list_digits)         #找出数字列表的最大值

列表解析【之前没接触过的语法】

list = [value**2 for value in range(1,11)]    #一行代码生成列表

for循环 长度 类似于java的增强for循环

len(list)                #确定列表长度
for i in list:           #打印整个列表
    print(i)

切片 左闭右开

list[0:3]                #输出一个包含列表第1到3个元素的列表，没有list[3]
list[:4]                 #输出一个包含列表前四个元素的列表
list[2:]                 #输出一个包含列表第三个元素开始往后的元素的列表
list[-3:]                #输出一个包含列表最后三个元素的列表

复制列表

list2 = list1[:]

注意不能 list2 = list1 这样本质上是同一个列表，发生操作会同时改变

判断元素是否在或不在列表中

list = ['trek','cannondale','redline','specialized']
print('trek' in list)
print('trek' not in list)

元组

不可修改的列表称为元组。 存放不可改变的值 圆括号()

tuple = (200,50)             #两个元素的元组
tuple[0] = 10                #不合法 
tuple = (100,10)             #可以给储存元组的变量重新赋值，合法

if语句

elif 是java中else if的缩写

#检查单个条件
if car == 'bmw':
    print(car.upper())
elif car == 'saf':
    print(car.lower())
else:
    print(car.title())
#检查多个条件
if age_0 >= 21 and age_1 >= 21
if age_0 >= 21 or age_1 >= 21
#检查特定值是否在列表中，特定值是否在字符串中同理
if 'value' in list
if 'value' not in list
#确定列表不是空的
if list

字典

字典是一系列的键值对：

dict = {
    
    'color':'green','points':5}

1. 取值 两种方式

dict['color']         #访问字典中'color'所对应的值
dict.get('color','color is null') 

使用get取值可以防止没有这个键而报错，输出第二个值 ‘color is null’ ，没有第二个默认输出None

1. 增删改

#字典是动态结构，可随时在其中添加键值对,键值对的排列顺序和添加顺序不同，Python不关心键值对顺序，只关心键与值的联系
dict['x_position'] = 0 
dict = {
    
    'color':'green','points':5,'x_position':0}
#修改字典中的值
dict['x_position'] = 10
#修改字典中的值
dict['x_position'] = 10

1. 遍历

• dict.items() 返回的是键值对列表
• dict.keys() 返回的是key列表
• dict.values() 返回的是value列表
• set() 返回去重集合

#遍历字典
for key,value in dict.items():       #item方法返回一个键值对列表，依次是键，值，键，值。。。
    print(key)
    print(value)
for key in dict.keys():              #遍历字典所有键
    print(key);
for key in sorted(dict.keys()):      #按顺序遍历字典所有键
    print(key);   
for value in dict.values():
	print(value)
for value in set(dict.values()):
    print(value)
    

• 集合与列表的不同

同样都是花括号表示 集合输出不重复元素

languages = {
    
    'python','c','c++','c'}
print(languages)
{
    
    'c', 'c++', 'python'}

用户输入

• 函数input()让程序暂停运行，等待用户输入文本，获取用户输入后，Python将其储存在一个变量中，供你使用：

message = input("Tell me something,and I will repeat it back to you:")         #获取输入，input中是提示信息
print(message)

• input()接收值会被当成str类型 如果想要变为int类型需要进行转换int(message)

while

num = 1
while num <= 5:
    print(num)
    num++
    if city == 'quit':      #可以设定条件主动退出循环
        break               #continue为退出本次循

• 在for循环中不应修改列表，否则将导致Python难以跟踪其中的元素，可使用while进行修改：

unconfirmed_users = ['alice','brian','candace']
confirmed_users = []
while unconfirmed_users:                       #验证所有未验证用户，并从旧列表中删除，将已验证用户加入新列表中
    current_user = unconfirmed_users.pop()
    print(current_user.title())
    confirmed_users.append(current_users)

• 删除包含特定值的所有列表元素

while 'cat' in pets:
    pets.remove('cat')

函数

def greet_user():
    print('Hello!')

参数 返回值

• 实参 分为位置实参与关键字实参
• 形参 形参可以设置默认值

def describe_pet(animal_type = ‘rabbit’,pet_name = 'snoby'):       #两个参数，可以给形参设定默认值，这样就可以不用传入实参
    print("I have a" + animal_type + '.The name is' + pet_name)    
describe_pet('hamster','harry')                                    #位置参数
describe_pet(animal_type = 'hamster',pet_name = 'harry')		   #关键字参数

返回值

#有返回值的函数
def git_fromatted_name(first_name,last_name):
    full_name = first_name + last_name
    return full_name.title()	                              
#return {'first':first_name,'last':last_name}    可返回字典

参数可以是列表

如果不想改变原来的列表，可以使用切片，传副本list[:]

#把列表传给函数后，函数可以直接对其进行修改,注意这在简单数据类型行不通。如果不想修改列表本身可以用list[:]副本传入
def print_models(unprinted_designs,completed_models):
    while unprinted_designs:
        current_designs = unprinted_designs.pop()
        print('Printing model:' + current_design)
        completed_models.append(current_design)

传递任意数量的实参

• *toppings 表示元组
• **user_info 表示字典

def make_pizza(*toppings):                                        #这里toppings是一个元组，可以传入任意数量的元素
    print(toppings)
make_pizza('mushrooms','green peppers','extra cheese')            #调用函数，传入的参数自行组成元组
def make_pizza(size,*toppings):                                   #结合使用    
    print("make a " + size + "pizza with the following toppings:")
    for topping in toppings:
        print("- " + topping)
#使用任意数量的关键字实参（传入任意数量元素的字典）
def build_profile(first,last,**user_info):                         #传入信息和键值对，合并成一个字典
    user_info['first_name'] = first
    user_info['last_name'] = last
    return user_info
bild_profile('albert','einstein',location = 'princeton',field = 'physics')      #调用

模块

将函数储存在模块中，创建一个存储函数的独立文件，在其所在目录中的其他py文件都可以通过import+文件名导入模块

• 导入整个模块

#pizza.py
def make_pizza(*toppings):                                        
    print(toppings)
#making_pizzas.py
import pizza                          
pizza.make_pizza('mushroom','green peppers','extra cheese')
#import pizza as p 可以给模块指定别名

• 导入具体函数

#导入特定函数
from pizza import make_pizza as mp           #可以给函数指定别名
#导入模块中所有函数
from pizza import *

类

定义 实例

init() 类似于java构造器

#创建一个类
#self是一个指向实类本身的引用，让实例能访问类中的属性和方法。
#Python调用_init_()方法来创建实例时会自动传入实参self，我们自己不需要传递它。
class Dog():
    def __init__(self,name,age):   #注意init两边的横线的两条杠            
        self.name = name
        self.age = age
        self.model = 0             #可以在此处定义另外没传入的变量
    def sit(self):
        print(self.name.title() + ‘is now sitting.’)
    def roll_over(self):
        print(self.name.title() + 'rolled over!')
    def update_model(self,model):
        self.model = model
#创建实例
my_dog = Dog('willie',6)
my_dog.name                        #访问实例中的变量
my_dog.age                         #访问实例中的变量
my_dog.sit()                       #调用类中的方法
#修改属性的值
my_dog.model = 10                  #大多数情况为了封装完整，应该使用方法对属性进行修改
my_dog.update_model(10)            #这样修改

继承

#假设前面已有一个Car类
class ElectricCar(Car):
    def __init__(self,make,model,year):
        super()._init_(make,model,year) #super是一个特殊函数，将父类和子类联系起来，代表了父类，此处父类和子类的_init_函数保持一致
        #此处编写ElecticCar类的独特属性
#子类可以重写父类的方法
#可以将实例用作属性
class Battery():
    --skip
class ElectricCar(car):
    def _init_(self,make,model,year):
        super()._init_(make,model,year)
        self.battery = Battery();              #实例作属性

导入类

#car.py
Class Car():
    --skip
#my_car.py
from car import Car          
#导入整个模块用import car，运用是要在类前加mudule_name.。
导入模块中所有类用from car import *
my_new_car = Car('audi','a4',2016)

文件

读

使用with关键字，python会自动进行文件的打开和关闭

指定编码 中文得指定,encoding='utf-8'

#读取文件，显示内容，不需要主动调用close
#当前项目下
with open('hello.txt',encoding='utf-8') as file_object:   #文件命名为file_object。相对路径行不通可以用绝对路径
    contents = file_object.read()            #读取文件内容，传入字符串中
    print(contents.rstrip())                 #rstrip()方法删除字符串末尾的空白
#当前项目下某文件夹下 相对路径
with open('test/hello.txt',encoding='utf-8') as file_object:   
    contents = file_object.read()           
    print(contents.rstrip())                
#绝对路径 注意\要多加一个\进行转义
with open('C:\\Users\\Mono\\Desktop\\hello.txt',encoding='utf-8') as file_object:   
    contents = file_object.read()           
    print(contents.rstrip())                 

逐行读取

filename = 'hello.txt'
#readlines()方法从文件中读取每一行，储存在一个列表中
with open(filename,encoding='utf-8') as file_object:
    for line in file_object:
        print(line.strip())

将文本类型转化为列表

#readlines()方法从文件中读取每一行，储存在一个列表中
filename = 'hello.txt'
with open(filename,encoding='utf-8') as file_object:
    lines = file_object.readlines()         
for line in lines:
    print(line.strip())

写

写入文本文件只能写入str类型，int需要进行转换

读取模式：

• r 只读 【默认】
• w 覆盖写
• a 追加写
• r+ 读写

如果文件不存在，open操作会自动创建空文件

#整体写入
with open(filename,'w') as file_object:             #以写入模式打开文件，如果文件不存在会自动创建，已经存在会清空文件
    file_object.write("I love programming.")        #注意只能写入字符串，写入多行时可以加换行符
#附加内容
with open(filename,'a') as file_object:             #以附加模式打开文件，不会清空原有文件，写入的行添加到文件末尾
    file_object.write("I love programming.")  

异常

python（try - except - else）与java(try - catch - finally)不太一样

• else是没异常才执行
• finally一定执行

pass用于在except中对异常静默处理

try:
    print(5/0)
except ZeroDivisionError:
    print('You can\'t divide by zero!')
else:                                                              #正常运行
    print("answer")
#处理文件找不到的异常
try:
    with open(filename) as f_obj:
        contents = f_obj.read()
except FileNotFoundError:
    msg = "Sorry,the file" + filename + "does not exist."          
    #如果这里写pass，错误时可以不输出信息
    print(msg)

实例

str.split()            #以空格为分隔符将字符串拆分为多个部分，并储存到一个列表中
#计算文本单词数
def count_words(filename):
    try:
        with open(filename) as f_obj:
            contents = f_obj.read()
    except FileNotFoundError:
        print('Sorry,the file does not exist')
    else:
        word = contents.split()
        num_words = len(words)
        print("The file " + filename + "has about " + str(num_words) + " words.")

存储与读取运行数据

使用json格式 需要导入json模块

• 存：json.dump(object,filename) dump是转存的意思
• 读：json.load(filename)

import json
numbers = [2,3,5,7,11,13]
filename = 'numbers.json'
with open(filename,'w') as f_obj:
    json.dump(numbers,f_obj)         #传入要储存的数据和储存数据的文件对象
#文件中数据存储格式和Python中一样[2,3,5,7,11,13]
#再将列表读取到内存中
with open(filename) as f_obj:
    numbers = json.load(f_obj)       #列表被读取出来
    print(numbers)

测试

__ name__的作用

• 在本模块时__ name= main__
• 而当本模块被其他模块导入时__ name__=模块名
• 可以以此来区分模块，假如A模块有代码不想被B导入导入后执行就添加一下代码

if __name__ == '__main__':
    print_hi('PyCharm')

测试函数

Python标准库中的模块unittest提供了测试工具，单元测试用于核实函数的某个方面没有问题。

def get_formatted_name(first,last):
    """生成姓名"""
    full_name = f"{
      
      first} {
      
      last}"
    return full_name.title()
import unittest
from name_function import get_formatted_name
#测试类,所有以test_开头的方法自动运行
class NamesTestCase(unittest.TestCase):                     #必须继承unittest.TestCase
    def test_first_last_name(self):                         #核实名和姓能否被正确格式化
        formatted_name = get_formatted_name('janis','joplin')
        self.assertEqual(formatted_name,'Janis Joplin')     #断言方法，核实得到的结果与期望是否一致
if __name__ == '__main__':
    unittest.main()
#如果全部测试通过会输出OK,第一行的句点表明几个测试通过
#不通过第一行会有E,最后显示FALLED
#测试不通过时，意味新代码有错。不要修改测试，而应修改导致测试不通过的代码。

测试类

#假设已经创建了一个匿名调查类AnonymousSurvey
from survey import AnonymousSurvey
import unittest
class TestAnonmyousSurvey(unittest.TestCase):
    def test_store_single_response(self):
        question = 'what language did you first learn to speak?'
        my_survey = AnonymousSurvey(question)                #问题
		my_survey.store_response('English')                  #答案，会添加到答案列表中  
        my_survey.store_response('Chinese')
        self.assertIn('English',my_survey.responses)
if __name__ == '__main__':
    unittest.main()

setUp()

可使用setUp()方法进行初始化

继承unittest.TestCase会率先执行setUp()方法 随后逐一执行test_开头的方法

from survey import AnonymousSurvey
import unittest
class TestAnonmyousSurvey(unittest.TestCase):
    def setUp(self):
        question = 'what language did you first learn to speak?'
        my_survey = AnonymousSurvey(question)                        #输入问题
        self.responses = ['English','Spanish','Mandarin']
    def test_store_single_response(self):                            #测试一个答案 
		my_survey.store_response(self.responses[0])                 
        self.assertIn(self.responses[0],my_survey.responses)
    def test_store_three_responses(self):                            #测试三个答案
        for response in self.responses:
            self.my_survey.store_reponse(response)
        for response in self.responses:
            self.assertIn(response,self.my_survey.responses)
unittest.main()