Python基础实践

# print函数
i = 8
print(i, i + 1, "The Value is:" + str(i))

# print函数 指定以 " " 结尾
for i in range(1, 10) :
    print(i, end = " ") # 不以换行结尾

# title 函数
message = 'aDA ada AdA'
print(message.title()) # 将每个单词首字母大写其余小写
>>> Ada Ada Ada

# lower
message = 'aDA ada AdA'
print(message.lower())
>>> ada ada ada

# upper
message = 'aDA ada AdA'
print(message.upper())
>>> ADA ADA ADA

# strip & rstrip & lstrip
message = ' python '
print(message.rstrip()) # ' python'
print(message.lstrip()) # 'python '
print(message.strip()) # 'python'

# 字符串的单引号&双引号
message = 'attention "Do not touch that"'
message2 = "haha this is jack's girl friend"
print(message)
print(message2)

# ** 乘方运算
message = 3 ** 2 # 3的2次方 = 9
print(message)

# 小数 结果包含的小数位数可能是不确定的
print(0.2 + 0.1) # 0.30000000000004
print(0.1 + 0.1) # 0.2

# 获取 python之禅
import this

# 列表 访问
list = ['a', 'b', 'c']
print(list[0]) # a
print(list[-1]) # 最后一个
print(list[-2]) # 倒数第二个

# 列表 修改
list = ['a', 'b', 'c']
print(list)
list[0] = 'aa'
print(list)

# 列表 添加
list = []
list.append('a')
list.append('b')
list.append('c')
print(list)

list = ['a', 'b', 'c']
list.insert(0, 'aa')
print(list)

# 列表 删除
list = ['a', 'b', 'c']
del list[0]
print(list)

list = ['a', 'b', 'c']
print(list)
pop = list.pop() # 删除 'c'
print(list)
print(pop)

list = ['a', 'b', 'c']
print(list)
pop = list.pop(0) # 删除索引为0的元素
print(list)
print(pop)

list = ['a', 'b', 'c', 'a']
print(list)
del_node = 'a'
list.remove('a') # 只删除第一个 'a'
print(list)

# 列表 组织
list = ['b', 'a', 'c', 'd']
print(list)
list.sort()
print(list)
list.sort(reverse=True) # 反向排序
print(list)

list = ['b', 'a', 'd', 'c']
print(list)
print(sorted(list)) # 不影响原 list
print(sorted(list, reverse=True))
print(list)

list = ['a', 'b', 'c', 'd']
list.reverse() # 反转列表
print(list)

list = ['a', 'b', 'c', 'd']
print(len(list)) # 列表长度

list = []
print(list[-1]) # 越界 -1表示最后一个元素

# 将 数字集 转化 为 列表
numbers = list(range(1, 6))
print(numbers) # 1, 2, 3, 4, 5

even_numbers = list(range(2, 11, 2)) # 步长2
print(even_numbers)

squares = []
for v in range(1, 11) :
    squares.append(v**2)
print(squares)

# 列表 统计 计算
nodes = [1, 2, 3, 4, 5, 9, 0]
print(min(nodes))
print(max(nodes))
print(sum(nodes))

# 列表解析
squares = [square ** 2 for square in range(1, 11)]
print(squares)

# 列表 切片
nodes = ['a', 'b', 'c', 'd'] # 切片从索引0开始
print(nodes[0:3]) # a,b,c
print(nodes[1:4]) # b,c,d
print(nodes[:4]) # a,b,c,d
print(nodes[2:]) # c,d
print(nodes[-3:]) # b,c,d

# 列表 切片 遍历
nodes = ['a', 'b', 'c', 'd']
for node in nodes[:3] :
    print(node.title())

# 列表 复制
nodes = ['a', 'b', 'c', 'd']
nodes1 = nodes # nodes和nodes1 指向相同地址
nodes2 = nodes[:] # nodes和nodes2 各自有一份 互不干涉
nodes.append('00')
nodes1.append('11')
nodes2.append('22')
print(nodes)
print(nodes1)
print(nodes2)

# 列表 判断是否为空
nodes = []
if nodes :
    print("nodes is not empty")
else :
    print("nodes is empty")

# 元组(不能被修改的列表)
nodes = (100, 200)
print(nodes[0])
print(nodes[1])
nodes[0] = 111 # 不能通过 元组值不允许被修改

# 元组 遍历
nodes = (100, 200)
for node in nodes :
    print(node)

# 元组变量修改
nodes = (100, 200)
for node in nodes :
    print(node)
nodes = (200, 400) # 变量可被重新赋值
for node in nodes :
    print(node)

# if 条件判断
nodes1 = ['a', 'b', 'c', 'd']
nodes2 = [1, 2, 3, 4]
node1 = 'e'
node2 = 2
if node1 in nodes1 and node2 in nodes2 :
    print("all in") # False
elif node1 in nodes1 or node2 in nodes2 :
    print("part in") # True

if node1 not in nodes1 :
    print("node1 not in nodes1") # True

#
\n 回车
\t 制表符

# range
for i in range(0,3) : # [0, 3)
    print(" -" + str(i))

#
for k, v in map.items() :
    print("key:" + k)
    print("value: + v)

#
for k in map.keys() : #Or  for k in map:
    print("key:" + k)

# 不在map的keys列表中
if 'erin' not in favorite_languages.keys() :
    print(" erin not in !!")

# 按照键值顺序，固定
for name in sorted(favorite_languages.keys()) :
    print(name.title())

# 打印values
for value in favorite_languages.values() :
    print(value.title())

# 打印values不重复
for value in set(favorite_languages.values()) :
    print(value.title())

#
friends = ['jen', 'edward'] # 列表
for name in favorite_languages.keys() :
    print(name.title())
    if name in friends : # 在列表中
        print(" Hi" + name.title() + 
            ", I see your favorite language is " + 
            favorite_languages[name].title() + "!")

# 打印list
a_0 = {'color' : 'green', 'points' : 5}
a_1 = {'color' : 'yellow', 'points' : 10}
a_2 = {'color' : 'red', 'points' : 15}
a_list = [a_0, a_1, a_2]
for a in a_list :
    print(a)

# 动态增list元素 & 打印list的前多少个 & 求list的长度 & range
b_list = []
for i in range(30) :
    new_b = {'color' : 'green', 'points' : 5, 'speed' : 'slow'}
    b_list.append(new_b)

for b in b_list[:5] : # 前5个
    print(b)
print("...")
print("Total number of b:" + str(len(b_list)))

# list 条件判断
for b in b_list[0:3] : # 0开始的3个元素
    if b['color'] == 'green' :
        b['color'] = 'yellow'
        b['speed'] = 'fast'
        b['points'] = 10
    elif b['color'] == 'yellow' :
        b['color'] = 'red'
        b['speed'] = 'fast'
        b['points'] = 15

for b in b_list[:5] :
    print(b)
print("...")

# map里嵌套list
favorite_language = {
    'hailong' : ['C', 'C++', 'Python'],
    'jack' : ['C'],
    'meimei' : ['Java', 'Go'],
    'yuanyuan' : ['H5'],
    }

for k, v in favorite_language.items() :
    if len(v) == 1 :
        print("\n" + k.title() + " has one favorite:")
    else :
        print("\n" + k.title() + " has some favorite language:")
    for l in v :
        print("\t" + l.title())

# map里嵌套map
users = {
    'aeinstein' : {
        'first' : 'albert',
        'last' : 'aeinstein',
        'location' : 'new york'
        },
    'mcurie' : {
        'first' : 'marie',
        'last' : 'curie',
        'location' : 'pairs'
        }
    }

for name, info in users.items() :
    print("\n username:" + name.title())
    full_name = info['first'] + " " + info['last']
    location = info['location']

    print("\t full name is:" + full_name.title())
    print("\t location:" + location.title())

# 接收输入，与用户交互
message = input("tell me some message:")
print (message)
    # 如果用的是python2.7  请用raw_input

# 拼接多行字符串
prompt = "balabalabala"
prompt += "\nwhat is your name:"
message = input(prompt)
print("\nHello, " + message + "!")

# while使用
start = 1
while start <= 5 :
    print("\n number:" + str(start))
    start += 1

# while & bool
prompt = "input value, and i will echo to you,"
prompt += "\n if you enter 'quit', exit programe:"
message = ""
active = True
while active :
    message = input(prompt)

    if message == 'quit' :
        active = False
    else :
        print(message)

# break的使用
prompt = "\n tell me what city do you go:"
message = ""
while True :
    message = input(prompt)

    if message == 'quit' :
        break

    print("the city you want to go is:" + message.title())

# continue的使用
cur_number = 0
while cur_number < 10 :
    cur_number += 1

    if cur_number % 2 == 0 :
        continue

    print(cur_number)

# 遍历list & list放在while中删除 & list的pop
unconfirm_list = ['a', 'b', 'c']
confirm_list = []
while unconfirm_list : # 只能用while 不能用 for
    cur = unconfirm_list.pop() # c -> b ->a

    print("cur user is:" + cur.title())
    confirm_list.append(cur) # 加入

for cu in confirm_list :
    print("confirm member:" + cu.title())

# list的循环遍历删除(删除多个元素)
pet_list = ['a', 'b', 'c', 'a', 'a', 'd', 'f']
print(pet_list)
while 'a' in pet_list :
    pet_list.remove('a')

print(pet_list)

# while & input & map
response = {}
b_active = True
while b_active :
    name = input("What's you name:")
    mountain = input("What moutain do you like:")

    response[name] = mountain

    ack = input("do you want continue(yes/no):")
    if ack == 'no' :
        b_active = False
    
for k, v in response.items() :
    print("Hi, " + k + ", do you want climb " + v)

# 函数
def sayHello() :
    """ say hello """  #[docstring] 生成文档用的注释
    print("Hello!!!!")

sayHello()

# 函数 带参数
def sayHello(name) :
    """ say hello """ # docstring
    print("Hello " + name.title() + " !")

sayHello('hailong')

# 函数 位置实参 多个
def showAnimal(type, name) :
    print("\n I have a type:" + type.title() + " animal, name:" + name.title())

showAnimal('cat', 'mimi')
showAnimal('dog', 'taotao')

# 函数 关键字实参 再也不用担心传的顺序不对了
def showAnimal(type, name) :
    print("\n I have a type:" + type.title() + " animal, name:" + name.title())

showAnimal(type='cat', name='mimi')
showAnimal(name='mimi', type='cat')

# 函数 参数 默认值
def showAnimal(name, type='dog') :
    print("\n I have a type:" + type.title() + " animal, name:" + name.title())

showAnimal(name='mimi')
showAnimal('taotao')

# 函数 返回值
def get_clean_name(first, family) :
    full_name = first + ' ' + family
    return full_name.title()

my_name = get_clean_name('jack', 'shi')
print(my_name)

# 函数 默认值 判断字符串是否为空
def get_formatted_name(first, last, middle='') :

    if middle : # 直接判断是否为空
        full_name = first + ' ' + middle + ' ' + last
    else :
        full_name = first + ' ' + last

    return full_name.title()

my_name = get_formatted_name('jack', 'shi')
print(my_name)
my_name = get_formatted_name('jack', 'shi', 'tang')
print(my_name)

# 函数 返回map
def build_person(first, last) :
    person = {'first' : first, 'last' : last}
    return person

my_person = build_person('hailong', 'shi')
print(my_person)

# 函数 返回map 默认值
def build_person(first, last, age='') :
    person = {'first' : first, 'last' : last}
    if age :
        person['age'] = age
    return person

my_person = build_person('hailong', 'shi', 27) # map的age为int型27 以实参为准
print(my_person)

# 函数 返回值 & while & break
def get_formatted_name(first, last) :
    full_name = first + ' ' + last
    return full_name.title()

while True :
    f_name = input("Input first name:")
    if f_name == 'q' :
        break
    l_name = input("Input last name:")
    if l_name == 'q' :
        break

    my_fullname = get_formatted_name(f_name, l_name)
    print(my_fullname)

# 函数 传参list & 字符串拼接
def greet_user(names) :
    for name in names :
        msg = "Hello " + name.title() + "!"
        print(msg)

user_list = ['hailong', 'yuanyuan', 'taotao']
greet_user(user_list)

# 函数 参数list回传 & docstring &
def printModules(un, ed) :
    """
    docstring 说明 # 可以嵌套注释
    """
    while un :
        cur = un.pop()
        print("pop from list:" + cur)
        ed.append(cur)

def showModule(l) :
    for node in l :
        print(node)
    
my_list = ['a', 'b', 'c', 'd']
ed_list = []
printModules(my_list, ed_list) #回传 ed_list
showModule(ed_list)

# 函数 参数list不能被函数修改
def printModules(un, ed) :
    """
    docstring 说明 # 说明
    """
    while un :
        cur = un.pop()
        print("pop from list:" + cur)
        ed.append(cur)

def showModule(l) :
    for node in l :
        print(node)
    
my_list = ['a', 'b', 'c', 'd']
ed_list = []
printModules(my_list[:], ed_list) # 传my_list的切片副本 不会被函数内部修改
showModule(my_list)
showModule(ed_list)

# 函数 可变实参
def make_pizza(*toppings) : # 注意toppings前面的*
    print("Make a pizz need some toppings:")
    for t in toppings :
        print("- " + t)

make_pizza('a')
make_pizza('a', 'b', 'c', 'd')

# 位置实参 & 可变实参(可变实参用list收藏)
def make_pizza(size, *toppings) :
    print("Make a " + str(size) + " inch pizz need some toppings:")
    for t in toppings :
        print("- " + t)

make_pizza(11, 'a')
make_pizza(18, 'a', 'b', 'c', 'd')

# 位置实参 & 可变实参(可变实参用map收藏)
def build_profile(first, last, **var) :
    # **user_info中的两个星号为可变数量的关键字实参创建字典供
        # 供函数内部使用
    profile = {}
    profile['first'] = first
    profile['last'] = last
    for k, v in var.items() :
        profile[k] = v
    
    return profile

my_profile = build_profile('hailong', 'shi', city='shanghai', job='it')
print(my_profile)

# 导入整个模块里的所有函数
def make_pizza(size, *toppings) :
    """ pizza.py """
    print("Make " + str(size) + " pizza, need toppings below:")
    for topping in toppings :
        print(" -" + topping)

 """ test.py """
import pizza
pizza.make_pizza(15, 'a', 'b') # 需要 pizza后面跟点
pizza.make_pizza(18, 'a', 'b', 'c')

# 导入整个模块里的所有函数2     import * 版
def make_pizza(size, *toppings) :
    """ pizza.py """
    print("Make " + str(size) + " pizza, need toppings below:")
    for topping in toppings :
        print(" -" + topping)

def fun_b() :
    print("fun_b")

 """ test.py """
import pizza *
make_pizza(15, 'a', 'b') # 需要 pizza后面跟点
make_pizza(18, 'a', 'b', 'c')
fun_b()

# 导入模块里的特定函数
def make_pizza(size, *toppings) :
    """ pizza.py """
    print("Make " + str(size) + " pizza, need toppings below:")
    for topping in toppings :
        print(" -" + topping)

 """ test.py """
from pizza import make_pizza # 特定函数
from pizza import * # 导入所有函数 但是容易重名 尽量少用
make_pizza(15, 'a', 'b') # 不要要点
make_pizza(18, 'a', 'b', 'c')

# 导入模块里的特定函数  并且 指定别名
def make_pizza(size, *toppings) :
    """ pizza.py """
    print("Make " + str(size) + " pizza, need toppings below:")
    for topping in toppings :
        print(" -" + topping)

 """ test.py """
from pizza import make_pizza as mp
mp(15, 'a', 'b') # 不要要点
mp(18, 'a', 'b', 'c')

# 导入整个模块 并且 把模块 指定别名
def make_pizza(size, *toppings) :
    """ pizza.py """
    print("Make " + str(size) + " pizza, need toppings below:")
    for topping in toppings :
        print(" -" + topping)

 """ test.py """
import pizza as mn
mn.make_pizza(15, 'a', 'b') # 不要要点
mn.make_pizza(18, 'a', 'b', 'c')

# 导入类
""" xxx.py """
class A() :
    -- snip --

""" test.py """
from xxx import A
my_a = A()

# 类定义 & 访问类实例属性 & 访问类实例方法
 # class Dog(object) :   # python2.7 的做法
class Dog() :
    """ 创建小狗 """

    def __init__(self, name, age) :
        """ initialize dog """
        self.name = name
        self.age = age

    def site(self) :
        """ simulate site down """
        print(self.name.title() + " site down")

    def rollover(self) :
        """ simulate rollover """
        print(self.name.title() + " roll over")


my_dog = Dog('taotao', 26)
print("my dog name:" + my_dog.name.title())
print("my dog age:" + str(my_dog.age))
my_dog.site()
my_dog.rollover()

# 类 访问属性 修改属性接口 属性默认值
class Car() :
    """ Car Info """

    def __init__(self, make, model, year) :
        """ Initialize """
        self.make = make
        self.model = model
        self.year = year
        self.mile = 0 # 属性默认值

    def get_full_name(self) :
        """ return full name """
        full_name = "The Car info:" + self.make + " " + self.model + " " + str(self.year)
        return full_name.title()

    def display_mile(self) :
        print("The car mile:" + str(self.mile))

    def update_mile(self, new_mile) : # 接口修改属性值
        if new_mile >= self.mile :
            self.mile = new_mile
        else :
            print("You can not roll back mile")
    def inc_mile(self, new_mile) :
        self.mile += new_mile

my_car = Car('audi', 'a4', 2016)
print(my_car.get_full_name())
my_car.display_mile()
my_car.update_mile(26)
my_car.display_mile()
my_car.update_mile(24)
my_car.display_mile()
my_car.mile = 24 # 直接修改属性值
my_car.display_mile()
my_car.inc_mile(100) # 通过接口增量修改属性值
my_car.display_mile()

# 类 继承
class EleCar(Car) :
    def __init__(self, make, model, year) :
        super().__init__(make, model, year) # 调用父类的 __init__函数

my_tesla = EleCar('tesla', 'model s', 2016)
print(my_tesla.get_full_name())

# python2.7的继承
class Car(object) :
    def __init__(self, make, model, year) :
    -- snip --

class EleCar(Car) :
    def __init(self, make , model, year) :

        # super需要2个实参 将父类和子类关联起来
        super(EleCar, self).__init__(make, model, year)
        -- snip --

# 类 继承 给子类增加属性和方法 & 重写父类的方法
class EleCar(Car) :
    def __init__(self, make, model, year) :
        super().__init__(make, model, year)
        self.battery = 70

    def display_battery(self) :
        print("The car battery:" + str(self.battery))

    def display_mile(self) : # 重写父类的方法
        print("Now I am in EleCar")

my_car = Car('aodi', 'a4, 2016)
my_tesla = EleCar('tesla', 'model s', 2016)
my_car.display_mile() # 调用父类的
my_tesla.display_mile() # 调用子类的
print(my_tesla.get_full_name())
my_tesla.display_battery()

# 类的组合
class Battery() :
    
    def __init__(self, battery_size=70) :
        self.battery_size = battery_size

    def show_battery(self) :
        print("The car's batter size:" + str(self.battery_size))

    def show_go_mile(self) :
        if self.battery_size == 70 :
            range = 240
        elif self.battery_size == 85 :
            range = 360

        print("The car can go " + str(range) + " miles under batter_size:" + str(self.battery_size))


class EleCar(Car) :
    def __init__(self, make, model, year) :
        super().__init__(make, model, year)
        self.battery = Battery(85)


my_tesla = EleCar('tesla', 'model s', 2016)
my_tesla.battery.show_battery()
my_tesla.battery.show_go_mile()

# 导入单个类 (被导入模块含单个类)
""" car.py """
class Car() :
    -- snip --

""" my_car.py """
from car import Car

# 导入单个类(被导入模块含多个类)
""" car.py """
class Car() :
    -- snip --

class EleCar(Car) :
    -- snip --

""" my_car.py """
from car import EleCar

# 从一个模块导入多个类
from car import Car, EleCar

my_car = Car('Audi', 'a6', 2016)
my_car.display_mile()
my_tesla = EleCar('tesla', 'model s', 2016)
my_tesla.battery.show_battery()
my_tesla.battery.show_go_mile()

# 导入整个模块  然后用 模块名.类名 实例化类
import car

my_car = car.Car('Audi', 'a6', 2016)
my_car.display_mile()
my_tesla = car.EleCar('tesla', 'model s', 2016)
my_tesla.battery.show_battery()
my_tesla.battery.show_go_mile()

# 导入模块内的所有类  --不建议使用
from car import *

my_car = Car('Audi', 'a6', 2016)
my_car.display_mile()
my_tesla = EleCar('tesla', 'model s', 2016)
my_tesla.battery.show_battery()
my_tesla.battery.show_go_mile()

# 模块分散 各自导入
""" car.py """
    -- snip --

""" ele_car """
    -- snip ---

""" my_car.py """
from car import Car
my_car = Car('Audi', 'a6', 2016)
my_car.display_mile()

from ele_car import EleCar
my_tesla = EleCar('tesla', 'model s', 2016)
my_tesla.battery.show_battery()
my_tesla.battery.show_go_mile()

# 标准库 - collections:OrderedDict
from collections import OrderedDict

f_l = OrderedDict()
f_l['a'] = 'a100'
f_l['b'] = 'b100'
f_l['c'] = 'c100'
f_l['d'] = 'd100'
for k, v in f_l.items() :
    print(" -" + k + " " + v.title())

# 文件  读取全部内容
with open('C:/Dev/pi.txt') as file_object :
    c = file_object.read()
    print(c.rstrip()) # 删除字符串末尾的空格 不再换行

# 文件 逐行读取文件
with open('C:/Dev/pi.txt') as file_object :
    for line in file_object :
        print(line.rstrip()) # 删除字符串末尾的空格 不再换行

# 文件  读取文件行保存在list 然后在外部使用
with open('C:/Dev/pi.txt') as file_object :
    lines = file_object.readlines()

for line in lines :
    print(line.rstrip())

# 文件 拼接所有行在一起
with open('C:/Dev/pi.txt') as file_object :
    lines = file_object.readlines()

pi_string = ''
for line in lines :
    pi_string += line.strip() # 删除所有的空格

print(pi_string)
print(len(pi_string))

# 文件 只获取文件的一部分内容
with open('C:/Dev/pi.txt') as file_object :
    lines = file_object.readlines()

pi_string = ''
for line in lines :
    pi_string += line.strip() # 删除所有空格

print(pi_string[:52] + "...") # 只获取52个字节
print(len(pi_string))

# 文件 检查文件内容是否包含指定字符串
with open('C:/Dev/pi.txt') as file_object :
    lines = file_object.readlines()

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

birth = input("Input your birthday:")
if birth in pi_string :
    print("You birth day is in")
else :
    print("You birth is not in")

# 文件  写文件
with open('C:/Dev/t.txt', 'w') as file_object :
    """ r w(写覆盖) a r+(读写) """
    file_object.write("Ha ha ha")

# 文件 写文件 加入 换行符
with open('C:/Dev/t.txt', 'w') as file_object :
    file_object.write("Ha ha ha1\n")
    file_object.write("Haha2\n")
    file_object.write("Haha3\n")

# 异常 异常码 汇总
ZeroDivisionError
FileNotFoundError

# 异常
try :
    print(5/0)
except ZeroDivisionError :
    print("Divide zero")

# 异常 else代码块
print("Enter two num, I will divide them:") 
print("Print q to exit")
while True :
    num1 = input("Fist number:")
    if num1 == 'q' :
        break
    num2 = input("Second number:")
    try :
        div = int(num1) / int(num2)
    except ZeroDivisionError :
        print("You can not divide 0")
    else :
        print("Result:" + str(div))

# 异常 FileNotFoundError
file_name = 'tt.txt'
try :
    with open(file_name) as file_object :
        content = file_object.read()
except FileNotFoundError :
    msg = "Sorry, the file " + file_name + " not found"
    print(msg)

# 文件 异常 字符串 split
try :
    with open('C:/Dev/pi.txt') as file_object :
        content = file_object.read()
except FileNotFoundError :
    msg = "File not found "
else :
    words = content.split() # words 现在是一个 list
    len = len(words)
    print("File have about " + str(len) + " Words")

# 文件 使用多个文件 pass
def count_times(file) :
    try :
        with open(file) as file_object :
            content = file_object.read()
    except FileNotFoundError :
        print("Do no find file:" + file) # pass 也可以用pass，占位符，啥都不做
    else :
        value = content.split()
        times = len(value)
        print("The file " + file + " have " + str(times) + " words")

file_list = ['ff.txt', 'C:/Dev/pi.txt']
for file in file_list :
    count_times(file)

# 文件 将数据存储为json文件
import json

numbers = [1, 2, 3, 4, 5]
with open('C:/Dev/tt.json', 'w') as file_object :
    json.dump(numbers, file_object)

# 文件 读取json文件
import json

with open('C:/Dev/tt.json') as file_object :
    numbers = json.load(file_object)

print(numbers)

# 文件&异常 函数 返回值 重构(多个小函数配合)
import json

def get_old_name() :
    filename = 'C:/Dev/name.json'
    try :
        with open(filename) as file_obj :
            username = json.load(file_obj)
    except FileNotFoundError :
        return None
    else :
        return username

def get_new_name() :
    username = input("Input your name:")
    filename = 'C:/Dev/name.json'
    with open(filename, 'w') as file_obj :
        json.dump(username, file_obj)
    return username

def greet_user() :
    user_name = get_old_name()
    if user_name :
        print("Welcome back:" + user_name + "!")
    else :
        username = get_new_name()
        print("Your new name is:" + username)
        
greet_user()

# 单元测试 函数 3个测试用例
import unittest

def get_full_name(first, last, middle='') :
    if middle :
        return first.title() + ' ' + middle.title() + ' ' + last.title() 
    else :
        return first.title() + ' ' + last.title()        

class NameTestCase(unittest.TestCase) :
    def test_name_case(self) : # 函数名必须以test开头 [测试用例1]
        full_name = get_full_name('hailong', 'shi')

        # 测试用例  通过
        self.assertEqual(full_name, 'Hailong Shi')
    
    def test_middle_case(self) : # 函数名必须以test开头 [测试用例2]
        full_name = get_full_name('hailong', 'shi', 'jack')

        # 测试用例  通过
        self.assertEqual(full_name, 'Hailong Jack Shi')

class NameTestCase2(unittest.TestCase) :
    def test_name_case(self) : # 函数名必须以test开头 [测试用例3]
        full_name = get_full_name('hailong', 'shi')

        # 测试用例  未通过
        self.assertEqual(full_name, 'hailong Shi')


unittest.main()

# 单元测试 各种断言方法
assertEqual(a, b)
assertNotEqual(a, b)
assertTrue(x)
assertFalse(x)
assertIn(x, list)
assertNotIn(x, list)

# 单元测试 类 2个测试用例
class AnoSurvey() :
    def __init__(self) :
        self.responses = []

    def add_response(self, value) :
        self.responses.append(value)

    def show_result(self) :
        for v in self.responses :
            print(" - " + v)

import unittest
class TestAnoSurvey(unittest.TestCase) :
    def setUp(self) : # 首先执行 setUp函数
        self.m_survey = AnoSurvey()
        self.m_testlist = ['english', 'chinese', 'japanese']

    def test_single_result(self) : # 单元测试1
        self.m_survey.add_response(self.m_testlist[0])
        
        self.assertIn(self.m_testlist[0], self.m_survey.responses)

    def test_three_result(self) : # 单元测试2
        for v in self.m_testlist :
            self.m_survey.add_response(v)

        for v in self.m_testlist :
            self.assertIn(v, self.m_survey.responses)

unittest.main()