Python

Python 列表转换字符串

例子：将列表 temp_list = ['h', 'e', 'l', 'l', 'o'] 转换成字符串'hello'，代码如下：

temp_list = ['h', 'e', 'l', 'l', 'o']
result = ''.join(temp_list)
print(result)    # hello

hello

字符串对象的方法join其描述如下:
大概意思是：s.join(iterable)是将括号内的迭代对象（如列表）使用s字符串作为链接将迭代对象中的元素拼接成一个字符串，返回该字符串。

Python中反转列表的三种方式

1.内建函数 reversed()

li =[1, 2, 3, 4, 5, 6]
a = list(reversed(li))
print (a)

注意：reversed()函数返回的是一个迭代器，而不是一个List，所以需要list函数转换一下

2.内建函数 sorted()

sorted()语法

sorted(iterable[, cmp[, key[, reverse]]])

参数说明：
iterable -- 可迭代对象。
cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

返回值

返回重新排序的列表。

a=[1,2,3,4,5,6,7,8,9] 
c=sorted(a, reverse=True) 
print (c)

注意：sorted()按降序排列，对于反转内容不是顺序排列的无效果，此处待改善。

3: 使用分片

a=[1,2,3,4,5,6,7,8,9] 
d=a[::-1] 
print （d） 　

注意：其中[::-1]代表从后向前取值，每次步进值为1

Python导入类

在一个模块中储存多个类

创建一个模块 car.py

class Car():
    """一次模拟汽车的简单尝试"""

    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0

    def get_descriptive_name(self):
        """返回整洁的描述性名称"""
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name.title()

    def read_odometer(self):
        """打印一条消息，指出汽车的里程"""
        print("This car has " + str(self.odometer_reading) + " miles on it.")

    def update_odometer(self,mileage):
        """
        将里程表读书设置为指定值
        拒绝将里程表回拨
        """
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't roll back an odometer!")

    def increment_odometer(self,miles):
        """将里程表的读书增加指定的量"""
        self.odometer_reading  += miles

class Battery():
    """一次模拟电动汽车电瓶的简单尝试"""

    def __init__(self,battery_size=70):
        """初始化电瓶的属性"""
        self.battery_size = battery_size

    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""
        print("This car has a " + str(self.battery_size) + "-KWh battery.")

    def get_range(self):
        "打印一条关于电瓶续航里程的消息"
        if self.battery_size == 70:
            range = 240
        elif sef.battery_size == 85:
            range = 270

        message = "This car can go approximately " + str(range)
        message += " miles on a full charge."
        print(message)

class ElectricCar(Car):
    """模拟电动汽车的独特之处"""
    def __init__(self,make,model,year):
        """
        初始化父类的属性，再初始化电动汽车特有的属性
        """
        super().__init__(make,model,year)
        self.battery = Battery()

导入单个类

创建一个实例my_car.py，导入Car类

from car import Car

my_new_car = Car('audi','a4','2016')
print(my_new_car.get_descriptive_name())

my_new_car.odometer_reading = 23

my_new_car.read_odometer()

在一个模块中储存多个类

导入ElectricCar类，创建一个电动车

from car import ElectricCar

my_tesla = ElectricCar('tesla','model s',2016)

print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()

从一个模块中导入多个类

将 Car 和 ElectricCar 类都导入

from car import Car,ElectricCar

my_beetle = Car('volkswagen','bettel',2016)
print(my_beetle.get_descriptive_name())

my_tesla = ElectricCar('tesla','roadster',2016)
print(my_tesla.get_descriptive_name())

导入整个模块

导入整个 car 模块

import car

my_beetle = car.Car('volkswagen','bettel',2016)
print(my_beetle.get_descriptive_name())

my_tesla = car.ElectricCar('tesla','roadster',2016)
print(my_tesla.get_descriptive_name())

Python文件

pi_digits.txt

3.1415926535
  8979323846
  2643383279

file_reader.py读取文件

with open('pi_digits.txt') as file_object:
    contents = file_object.read()
    print(contents.rstrip())

.rstrip()函数删除空行

逐行读取

filename = 'pi_digits.txt'

with open(filename) as file_object:
    for line in file_object:
        print(line.rstrip())
        """.strip()消除空白行"""

创建一个包含文件隔行内容的列表

.readlines()函数创建文件隔行内容的列表

filename = 'pi_digits,txt'

with open(filename) as file_object:
    lines = file_object.readlines()

for line in lines:
    print(line.rstrip)

使用文件的内容

filename = 'pi_digits.txt'

with open(filename) as file_object:
    lines = file_object.readlines()

pi_string = ''
for line in lines:
    pi_string += line.strip()

print(pi_string)
print(len(pi_string))

查询圆周率中的生日

file_name = 'pi_million_digits.txt'

with open(file_name) as file_object:
    lines = file_object.readlines()

pi_string = ''
for line in lines:
    pi_string += line.strip()

birthday = input("Enter your birthday,in the from mmddyy:")
if birthday in pi_string:
    print("Your birthday appears in the first million digits of pi!")
else:
    print("Your birthday does not appear in the first million digits of pi.")

写入文件

w 模式写入空文件

filename = 'programming.txt'

with open(filename,'w') as file_object:
    file_object.write("I love programming.\n")
    file_object.write("I love ctreating new games.\n")

w模式下，如果文件已经存在，将在返回文件对象前清空文件

a模式写入文件

filename = 'programming.txt'

with open(filename,'a') as file_object:
    file_object.write("I also love finding meaning in large datasets.\n")
    file_object.write("I love creating apps that can run in abrowser.\n")

***a模式下，写入的文件都将添加到文件末尾，如果指定文件不存在，将为你创建一个空文件

Python异常处理

try—except 代码块

ZeroDicisionError 处理

try:
    print(5/0)
except ZeroDivisionError:
    print("You can't divide by zero!")

FileNotFound处理

filename = 'DCcomics.txt'

try:
    with open(filename) as file_object:
        contents = file_object.readlines()

except FileNotFoundError:
    message = 'Sorry,the file ' + filename + ' does not exist'
    print(message)

try—excpet—else 代码块

print("Give me two numbers,and I wil divide them.")
print("Enter 'q' to quit.")

while True:
    first_number = input("\nFirst number:")
    if first_number == 'q':
        break
    second_number = input("Second number:")
    try:
        anwser = int(first_number) / int(second_number)
    except ZeroDivisionError:
        print("You can't divide by 0!")
    else:
        print(anwser)

Python分析文本

alice.txt

Alice in Wonderland

统计文件单词个数

filename = 'alice.txt'

try:
    with open(filename) as file_object:
        contents = file_object.read()

except FileNotFoundError:
    msg = 'Sorry, the file ' + filename + ' does not exist.'
    print(msg)

else:
    #计算文件大概包含多少个单词
    words = contents.split()
    num_words = len(words)
    print("The file " + filename + " has about " + str(num_words) + " words.")

统计多个文件

def count_words(filename):
    """计算一个文件大概包含多少个单词"""

    try:
        with open(filename) as file_object:
            contents = file_object.read()

    except FileNotFoundError:
        msg = 'Sorry, the file ' + filename + ' does not exist.'
        print(msg)

    else:
        #计算文件大概包含多少个单词
        words = contents.split()
        num_words = len(words)
        print("The file " + filename + " has about " + str(num_words) + " words.")

filenames = ['alice.txt','DCcomics','Batman vs Superman']
for filename in filenames:
    count_words(filename)

pass 语句

在 excpet 中使用

def count_words(filename):
    """计算一个文件大概包含多少个单词"""

    try:
        with open(filename) as file_object:
            contents = file_object.read()

    except FileNotFoundError:
        pass
    
    else:
        #计算文件大概包含多少个单词
        words = contents.split()
        num_words = len(words)
        print("The file " + filename + " has about " + str(num_words) + " words.")

filenames = ['alice.txt','DCcomics','Batman vs Superman']
for filename in filenames:
    count_words(filename)

json 储存数据

json.dump()

import json

numbers = [2,3,5,7,11,13]

filename = 'numbers.json'
with open(filename,'w') as file_object:
    json.dump(numbers,file_object)

json.load()

import json

filename = 'numbers.json'
with open(filename) as file_object:
    numbers = json.load(file_object)

print(numbers)

保存和读取用户生成的数据

remember_me

import json

username = input("What is your name?\n")

filename = 'username.json'
with open(filename,'w') as file_object:
    json.dump(username,file_object)
    print("We'll remember you when you come back," + username + "!")

greet_user

import json

filename = 'username.json'

with open(filename) as file_object:
    username = json.load(file_object)
    print("Welcome back, " + username + "!")

合并

import json

#如果以前储存了用户名，就加载它
#否则，就提示用户输入用户名并存储它

filename = 'username.json'

try:
    with open(filename) as file_object:
        username = json.load(file_object)

except FileNotFoundError:
    username = input("What's your name?\n")
    with open(filename,'w') as file_object:
        json.dump(username,file_object)
        print("We'll remember you when you come back, " + username + "!")

else:
    print("Welcome back, " + username + "!")

重构

import json

def get_stored_username():
    """如果存储了用户名，就获取它"""
    filename = 'username.json'
    try:
        with open(filename) as file_object:
            username = json.load(file_object)
    except FileNotFoundError:
        return None
    else:
        return username

def get_new_username():
    """提示用户输入用户名"""
    username = input("What is your name?\n")
    filename = 'username.json'
    with open(filename,'w') as file_object:
        json.dump(username,file_object)
    return username

def greet_user():
    """问候用户，并指出其名字"""
    username = get_stored_username()
    if username:
        print("Welcom back, " + username + "!")
    else:
        username = get_new_usrname()
        print("We'll remember you when you come back, " + username + "!")

greet_user()

Python测试代码

测试函数

name_function 函数

def get_formatted_name(first,last):
    """生成整洁的姓名"""
    full_name = first + ' ' + last
    return full_name.title()

def get_formatted_name_1(first,last,middle=''):
    """生成整洁的姓名"""
    if middle:
        full_name = first + ' ' + middle + ' ' + last
    else:
        full_name = first + last
    return full_name.title()

unittest 模块

创建一个继承 unittest.TestCase 的类，调用方法 assertEqual()

import unittest
from name_function import get_formatted_name_1

class NamesTestCase(unittest.TestCase):
    """测试name_function.py"""

    def test_first_last_name(self):
        """能够正确地处理像Janis Juplin这样的姓名吗？"""
        formatted_name = get_formatted_name_1('janis','joplin')
        self.assertEqual(formatted_name,'Janis Joplin')

    def test_first_last_middle_name(self):
        """能够正确地处理像Janis Juplin这样的姓名吗？"""
        formatted_name = get_formatted_name_1('janis','joplin','wall')
        self.assertEqual(formatted_name,'Janis Wall Joplin')

unittest.main()

测试类

各种 断言方法

assertEqual(a,b) 核实 a==b
assertNotEqual(a,b) 核实 a!=b
assertTure(x) 核实 x 为 True
assertFalse 核实 x 为 False
assertIn 核实 item 在 List 中
assertNotIn 核实 item 不在 List 中

帮助匿名调查的类

class AnonymousSurvey():
    """收集匿名调查问卷的答案"""

    def __init__(self,question):
        """储存一个问题，并为储存答案做准备"""
        self.question = question
        self.responses = []

    def show_question(self):
        """显示调查问卷答案"""
        print(self.question)

    def store_response(self,new_response):
        """储存单份调查答案"""
        self.responses.append(new_response)

    def show_results(self):
        """显示收集到的所有答案"""
        print("Survey results:")
        for response in self.responses:
            print(" -"  + response)

调用该类

from survey import AnonymousSurvey

#定义一个问题，并创建一个表示调差的AnonymousSurvey
question = "What language did you first learn to speak?"
my_survey = AnonymousSurvey(question)

#显示问题并储存答案
my_survey.show_question()
print("Enter 'q' at any time to quit.\n")
while True:
    response = input("Language: ")
    if response == 'q':
        break
    my_survey.store_response(response)

#显示调查结果
print("\nThank you to everyone who participated in the survey!")
my_survey.show_results()
    

测试 AnonymousSurvey 类

import unittest
from survey import AnonymousSurvey

class TestAnonymousSurvey(unittest.TestCase):
    """针对AnonymousSurvey类的测试"""

    def test_store_single_response(self):
        """测试单个答案会被妥善地储存"""
        question = "What language did you first learn to speak?"
        my_survey = AnonymousSurvey(question)
        my_survey.store_response('English')

        self.assertIn('English',my_survey.responses)

    def test_store_three_responses(self):
        """测试三个答案会被妥善地储存"""
        question = "What language did you first learn to speak?"
        my_survey = AnonymousSurvey(question)
        responses = ['Chinese','English','Spanish']
        for response in responses:
            my_survey.store_response(response)

        for response in responses:
            self.assertIn(response,my_survey.responses)

unittest.main()

方法 setUp

使用 setUp 改进测试代码

import unittest
from survey import AnonymousSurvey

class TestAnonymousSurvey(unittest.TestCase):
    """针对AnonymousSurvey类的测试"""

    def setUp(self):
        """创建一个调查对象和一组答案，供使用的测试方法使用"""

        question = "What language did you first learn to speak?"
        self.my_survey = AnonymousSurvey(question)
        self.responses = ['Chinese','English','Spanish']

    def test_store_single_response(self):
        """测试单个答案会被妥善地储存"""
        self.my_survey.store_response(self.responses[0])
        self.assertIn(self.responses[0],self.my_survey.responses)

    def test_store_three_responses(self):
        """测试三个答案会被妥善地储存"""
        for response in self.responses:
            self.my_survey.store_response(response)
        for response in self.responses:
            self.assertIn(response,self.responses)

unittest.main()

方法 setUp() 做了两件事：创建一个调查对象；创建一个答案列表。储存这两样东西的变量名包含前缀 self （即储存在属性中），因此可在这个类的任何地方使用。

Python isinstance()函数

isinstance() 与 type() 区别：

type() 不会认为子类是一种父类类型，不考虑继承关系。

isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

语法

以下是 isinstance() 方法的语法:

isinstance(object, classinfo)

参数

object -- 实例对象。
classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。

返回值

如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。。

实例

以下展示了使用 isinstance 函数的实例：

>>>a = 2
>>> isinstance (a,int)
True
>>> isinstance (a,str)
False
>>> isinstance (a,(str,int,list))    # 是元组中的一个返回 True
True

type() 与 isinstance()区别：

class A:
    pass
 
class B(A):
    pass
 
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False