python编程学习笔记⑧-2类

9.3继承
9.3.1子类的方法__init__()
父类在前，子类在后
子类包含圆括号，内写父类的名称。及父类实例所需的信息
再使用特殊函数super(),调用父类并写子类的特性
如

class Car:
	def __init__(self, make, model, year):
		self.make = make
		self.model = model
		self.year = year
		self.odometer_reading = 0

	--sinp--

class ElectricCar(Car):
	"""子类独特之处"""
	def __init__(self, make, model, year):
		"""初始化父类的属性，再初始化子类特有属性"""
		super().__init__(make, model, year):
		

9.3.2给子类定义属性和方法
属性和方法共有的加在父类，独有的加在子类。

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 = f"{self.year} {self.make} {self.model}"
		return long_name.title()

	def read_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 ElectricCar(Car):
	"""子类独特之处"""
	def __init__(self, make, model, year):
		"""初始化父类的属性，再初始化子类特有属性"""
		super().__init__(make, model, year) #使用在个就是为了省写代码
		self.battery_size = 75

	def describe_battery(self):
		print(f"这辆车的电池容量是{self.battery_size}-Kwh")

my_tesla = ElectricCar('tesla', 'model s', '2020')
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()
输出：
2020 Tesla Model S
这辆车的电池容量是75-Kwh
[Finished in 0.1s]

9.3.3重写父类的方法
假设父类中有一个方法。我们需要重写，只需要在子类中在使用这个方法名就可以，这时候子类会覆盖父类中的这个方法。
例如：父类中有一个方法fill_gas_tank()来描述汽车的油箱。但是子类电动汽车没有油箱，我们只需要在子类中在是用方法fill_gas_tank()，就可以覆盖父类的方法。

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 = f"{self.year} {self.make} {self.model}"
		return long_name.title()

	def read_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

	def fill_gas_tank(self):  #父类的描述油箱的方法
		print("这辆车有油箱")

class ElectricCar(Car):
	"""子类独特之处"""
	def __init__(self, make, model, year):
		"""初始化父类的属性，再初始化子类特有属性"""
		super().__init__(make, model, year) #使用在个就是为了省写代码
		self.battery_size = 75

	def describe_battery(self):
		print(f"这辆车的电池容量是{self.battery_size}-Kwh")

	def fill_gas_tank(self):   #子类也写一个父类已经有的方法，可覆盖父类方法
		print("这辆车没有油箱")

my_tesla = ElectricCar('tesla', 'model s', '2020')
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()
#执行的结果是子类的定义
my_tesla.fill_gas_tank()
输出：
2020 Tesla Model S
这辆车的电池容量是75-Kwh
这辆车没有油箱
[Finished in 0.1s]

9.3.4将实例用作属性

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 = f"{self.year} {self.make} {self.model}"
		return long_name.title()

	def read_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=75):
		"""初始化电瓶的属性"""
		self.battery_size = battery_size

	def describe_battery(self):
		"""打印电瓶容量的信息"""
		print(f"这辆车的电池容量是{self.battery_size}-Kwh")

	def get_range(self):
		"""打印，电瓶续航里程"""
		if self.battery_size == 75:
			range = 260
		elif self.battery_size == 100:
			range = 315
		print(f"你的电动车还可以行驶{range}公里")
class ElectricCar(Car):
	"""子类独特之处"""
	def __init__(self, make, model, year):
		"""初始化父类的属性，再初始化子类特有属性"""
		super().__init__(make, model, year) 
		#子类battery属性赋值来自于Battery（）这个类.其实这句是使用Battery()类创建了一个battery的实例。
		#Battery()括号内没写值因此使用75默认值
		self.battery = Battery()  

my_tesla = ElectricCar('tesla', 'model s', '2020')
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery() #实例my_tesla寻找实例battery调用方法describe_battery()
my_tesla.battery.get_range()
输出：
2020 Tesla Model S
这辆车的电池容量是75-Kwh
你的电动车还可以行驶260公里
[Finished in 0.1s]

疑惑：

def get_range(self):
		"""打印，电瓶续航里程"""
		if self.battery_size == 75:
			range = 260
		elif self.battery_size == 100:
			range = 315
		print(f"你的电动车还可以行驶{range}公里")

中的判断if 下面的range = 260 为什么要使用range。range()是创建数字列表函数。我原以为这里的range只是用户自定义的一个东西，后来发现不是如果不用这个单词就会返回<class ‘range’>
练习：9-6冰激凌小店

class Restaurant:
	"""模拟餐馆的类"""
	def __init__(self, restaurant_name, cuisine_type):
		"""初始化餐馆属性Restaurant_name和cuisine_type"""
		self.restaurant_name = restaurant_name
		self.cuisine_type = cuisine_type

	def describe_restaurant(self):
		"""描述餐厅"""
		print(f"这是一家{self.restaurant_name}餐馆，它有{self.cuisine_type}")

	def open_restaurant(self):
		"""营业时间"""
		print(f"{self.restaurant_name}正在营业，欢迎光临！")

class IceCreamStand(Restaurant):
	"""模拟冰激凌餐馆"""
	def __init__(self, restaurant_name, cuisine_type):
		"""初始化父类和子类"""
		super().__init__(restaurant_name, cuisine_type)
		self.flavors = []

	def show_flavors(self):
		"""出售的各种冰激凌"""
		print("\n出售的冰激凌有：")
		for flavor in self.flavors:
			print(f"-{flavor}")


my_iceCreamStand = IceCreamStand('牛牛', '冰激凌小店')
my_iceCreamStand.describe_restaurant()
my_iceCreamStand.flavors = ['牛奶冰激凌', '草莓冰激凌', '绿豆冰激凌']
my_iceCreamStand.show_flavors()
输出：
这是一家牛牛餐馆，它有冰激凌小店

出售的冰激凌有：
-牛奶冰激凌
-草莓冰激凌
-绿豆冰激凌
[Finished in 0.1s]

练习：9-7管理员
和上个题没什么区别

class User:
	"""创建以个User的类"""
	def __init__(self, first_name, last_name, ages):
		"""初始化用户的名和姓"""
		self.first_name = first_name
		self.last_name = last_name
		self.ages = ages

	def describe_user(self):
		"""用户信息摘要"""
		fuall_name = self.last_name + self.first_name
		print(f"这个用户叫：{fuall_name},今年{self.ages}")

	def greet_user(self):
		"""问候用户"""
		fuall_name = self.last_name + self.first_name
		print(f"你好{fuall_name}")

class Admin(User):
	def __init__(self, first_name, last_name, ages):
		super().__init__(first_name, last_name, ages)
		self.privileges = []

	def show_privileges(self):
		print("Admin的权限有：")
		for privilege in self.privileges:
			print(f"-{privilege}")

my_admin = Admin('Tachyon', 'xue', 20)
my_admin.describe_user()
my_admin.privileges = ['can add post', 'can delete post', 'can ban user']
my_admin.show_privileges()
输出：
这个用户叫：xueTachyon,今年20
Admin的权限有：
-can add post
-can delete post
-can ban user
[Finished in 0.1s]

练习9-8：权限

class User:
	"""创建以个User的类"""
	def __init__(self, first_name, last_name, ages):
		"""初始化用户的名和姓"""
		self.first_name = first_name
		self.last_name = last_name
		self.ages = ages

	def describe_user(self):
		"""用户信息摘要"""
		fuall_name = self.last_name + self.first_name
		print(f"这个用户叫：{fuall_name},今年{self.ages}")

	def greet_user(self):
		"""问候用户"""
		fuall_name = self.last_name + self.first_name
		print(f"你好{fuall_name}")

class Privileges:
	"""权限类"""
	def __init__(self, privileges=[]):			#注意这里要给属性一个默认值空的列表		
		self.privileges = privileges

	def show_privileges(self):
		print("Admin的权限有：")
		for privilege in self.privileges:
			print(f"-{privilege}")

class Admin(User):
	def __init__(self, first_name, last_name, ages):
		super().__init__(first_name, last_name, ages)
		self.privileges = Privileges()


my_admin = Admin('Tachyon', 'xue', 20)
my_admin.describe_user()
#下一行代码注意my_admin_privileges是一个新的列表变量
my_admin_privileges = ['can add post', 'can delete post', 'can ban user']
#下一行代码是一个赋值的过程，注意是实例传导子类实例在传导类。
my_admin.privileges.privileges = my_admin_privileges
my_admin.privileges.show_privileges()
输出：
这个用户叫：xueTachyon,今年20
Admin的权限有：
-can add post
-can delete post
-can ban user
[Finished in 0.1s]

练习：9-9电瓶升级

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 = f"{self.year} {self.make} {self.model}"
		return long_name.title()

	def read_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=75):
		"""初始化电瓶的属性"""
		self.battery_size = battery_size

	def describe_battery(self):
		"""打印电瓶容量的信息"""
		print(f"这辆车的电池容量是{self.battery_size}-Kwh")

	def get_range(self):
		"""打印，电瓶续航里程"""
		if self.battery_size == 75:
			range = 260
		elif self.battery_size == 100:
			range = 315
		print(f"你的电动车还可以行驶{range}公里")
	def upgrade_battey(self):
		"""检查电瓶容量"""
		if self.battery_size < 100:
			self.battery_size = 100
			print("将电瓶充电至100")
		else:
			print("充电完成")

class ElectricCar(Car):
	"""子类独特之处"""
	def __init__(self, make, model, year):
		"""初始化父类的属性，再初始化子类特有属性"""
		super().__init__(make, model, year) 
		#子类battery属性赋值来自于Battery（）这个类.其实这句是使用Battery()类创建了一个battery的实例。
		#Battery()括号内没写值因此使用75默认值
		self.battery = Battery()  

my_tesla = ElectricCar('tesla', 'model s', '2020')
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery() #实例my_tesla寻找实例battery调用方法describe_battery()
my_tesla.battery.get_range()
print("检查电瓶容量：")
my_tesla.battery.upgrade_battey()
print("开始充电.........")
my_tesla.battery.battery_size = 100 #改变电量
my_tesla.battery.upgrade_battey()
输出：
2020 Tesla Model S
这辆车的电池容量是75-Kwh
你的电动车还可以行驶260公里
检查电瓶容量：
将电瓶充电至100
开始充电.........
充电完成
[Finished in 0.1s]

9.4导入类
类可以储存在模块中，然后主程序可以导入所需的模块。
9.4.1导入单个类
先将类单独储存在一个.py的文件中。在新建一个.py文件。

from car import Car  #from 文件名 import 类名

9.4.2在一个模块中储存多个类
如何以个模块中储存了多个类，导入方法一样

from car import Battery  #from 文件名 import 某个类名

9.4.3从一个模块中导入多个类
导入多个类用逗号隔开类名

from car import Battery, Car #from 文件名 import 某个类名, 某个类名

9.4.4导入整个模块
使用import+文件名导入整个模块，在使用句点表示法访问需要的类

import car  #import+模块名
 
my_new_car = car.Car('volkswagen', 'beetle', '2019') #句点表示法 模块名.类名

9.4.5导入模块中的所有类
*代表所有

from car import *

这种方法不推荐，容易混淆。
9.4.6在一个模块中导入另一个模块
假如把Car类保存在car.py中，把Battery类保存在battety.py中，把ElectricCar类保存在electric_car.py中。
ElectricCar类需要的它的父类Car，则可以使用在electric_car.py文件中写入

from car import Car

创建主程序my_cars.py，可以这样写

from car import Car
from electric_car import ElectricCar

9.4.7使用别名
一样是是as

from electric_car import ElectricCar as EC

练习9-10：导入Restaurant类
restaurant.py文件

class Restaurant:
	"""模拟餐馆的类"""
	def __init__(self, restaurant_name, cuisine_type):
		"""初始化餐馆属性Restaurant_name和cuisine_type"""
		self.restaurant_name = restaurant_name
		self.cuisine_type = cuisine_type

	def describe_restaurant(self):
		"""描述餐厅"""
		print(f"这是一家{self.restaurant_name}餐馆，它有{self.cuisine_type}")

	def open_restaurant(self):
		"""营业时间"""
		print(f"{self.restaurant_name}正在营业，欢迎光临！")

class IceCreamStand(Restaurant):
	"""模拟冰激凌餐馆"""
	def __init__(self, restaurant_name, cuisine_type):
		"""初始化父类和子类"""
		super().__init__(restaurant_name, cuisine_type)
		self.flavors = []

	def show_flavors(self):
		"""出售的各种冰激凌"""
		print("\n出售的冰激凌有：")
		for flavor in self.flavors:
			print(f"-{flavor}")

9-10.py文件

from restaurant import Restaurant
my_iceCreamStand = Restaurant('牛牛', '冰激凌小店')
my_iceCreamStand.describe_restaurant()
my_iceCreamStand.open_restaurant()
输出：
这是一家牛牛餐馆，它有冰激凌小店
牛牛正在营业，欢迎光临！
[Finished in 0.1s]

练习9-11：导入Admin类

from a_user import Admin

my_admin = Admin('Tachyon', 'xue', 20)
my_admin_privileges = ['can add post', 'can delete post', 'can ban user']
my_admin.privileges.privileges = my_admin_privileges
my_admin.privileges.show_privileges()
输出：
Admin的权限有：
-can add post
-can delete post
-can ban user
[Finished in 0.1s]

练习9-12：多个模块
user.py

class User:
	"""创建以个User的类"""
	def __init__(self, first_name, last_name, ages):
		"""初始化用户的名和姓"""
		self.first_name = first_name
		self.last_name = last_name
		self.ages = ages

	def describe_user(self):
		"""用户信息摘要"""
		fuall_name = self.last_name + self.first_name
		print(f"这个用户叫：{fuall_name},今年{self.ages}")

	def greet_user(self):
		"""问候用户"""
		fuall_name = self.last_name + self.first_name
		print(f"你好{fuall_name}")

admin.py

from user import User

class Privileges:
	"""权限类"""
	def __init__(self, privileges=[]):			#注意这里要给属性一个默认值空的列表		
		self.privileges = privileges

	def show_privileges(self):
		print("Admin的权限有：")
		for privilege in self.privileges:
			print(f"-{privilege}")

class Admin(User):
	def __init__(self, first_name, last_name, ages):
		super().__init__(first_name, last_name, ages)
		self.privileges = Privileges()

9-12.py

from admin import Admin 

my_admin = Admin('Tachyon', 'xue', 20)
my_admin_privileges = ['can add post', 'can delete post', 'can ban user']
my_admin.privileges.privileges = my_admin_privileges
my_admin.privileges.show_privileges()
输出：
Admin的权限有：
-can add post
-can delete post
-can ban user
[Finished in 0.1s]

9.5python 标准库
好多

练习9-13：骰子
这个练习使用了python的标准库中的模块random，这是一个各种方式生产随进数的函数，randint()是返回一个指定范围内的整数。

from random import randint  #导入python的标准库中的random模块下的randint类

class Die:
	"""表示骰子的类"""
	def __init__(self):
		"""初始化骰子"""
		self.sides = 6

	def roll_die(self):
		"""返回1和骰子面数之间的随机数"""
		return randint(1, self.sides)#randint(1, self.sides)是randint类一个方法

d6 = Die()

results = []
for roll_num in range(10):   #range(10)代表循环10次
	result =d6.roll_die()
	results.append(result)

print("1-6，掷骰子10次")
print(results)

d10 = Die()
d10.sides = 10
results = []
for roll_num in range(10):
	result =d10.roll_die()
	results.append(result)

print("1-10，掷骰子10次")
print(results)

d20 = Die()
d20.sides = 20
results = []
for roll_num in range(10):
	result =d20.roll_die()
	results.append(result)

print("1-20，掷骰子10次")
print(results)
输出：
1-6，掷骰子10次
[3, 2, 6, 1, 2, 1, 2, 1, 2, 5]
1-10，掷骰子10次
[3, 10, 1, 4, 10, 2, 3, 8, 6, 5]
1-20，掷骰子10次
[20, 10, 18, 15, 4, 7, 8, 7, 4, 13]
[Finished in 0.1s]

练习9-14：彩票

from random import choice

number = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'a', 'b', 'c', 'd','e']
winning_number = []
print("现在开始摇动号码......")
while len(winning_number) < 4:
	wobble = choice(number)
	if wobble not in winning_number:
		print(f"摇出{wobble}放入奖池")
		winning_number.append(wobble)

print(f"今天的中奖号码是{winning_number}")
输出：
现在开始摇动号码......
摇出e放入奖池
摇出6放入奖池
摇出9放入奖池
摇出10放入奖池
今天的中奖号码是['e', 6, 9, 10]
[Finished in 0.1s]

练习：9-15：彩票分析
这个题不会做。

from random import choice
"""导入模块random，使用choice"""

def get_winning_ticket(possibilities):
	"""摇出中奖号码"""
	winning_ticket = []

	#使用while循环避免重复
	while len(winning_ticket) < 4:
		pulled_item = choice(possibilities)
		if pulled_item not in winning_ticket:
			winning_ticket.append(pulled_item)

	return winning_ticket


def check_ticket(played_ticket, winning_ticket):
	#检查彩票号码，在不在中奖组合里，只要有1个不是都返回False。
	for element in played_ticket:
		if element not in winning_ticket:
			return False

	return True

def make_random_ticket(possibilities):
	"""随机生成彩票"""
	ticket = []
	while len(ticket) < 4:
		pulled_item = choice(possibilities)
		#当随机生成的号码不在彩票中时，才将其添加到彩票中
		if pulled_item not in ticket:
			ticket.append(pulled_item)
	return ticket

possibilities = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'a', 'b', 'c', 'd','e']
# possibilities = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 26, 27, 28, 29, 30, 31, 32, 33]
winning_ticket = get_winning_ticket(possibilities)

plays = 0
won = False
# 设置最多随进生成多少张彩票
max_tries = 1_000_000

while not won:
	new_ticket = make_random_ticket(possibilities)
	won = check_ticket(new_ticket, winning_ticket)
	plays += 1
	if plays >= max_tries:
		break


if won:
	print("这是一张彩票")
	print(f"你的彩票是：{new_ticket}")
	print(f"中奖彩票是：{winning_ticket}")
	print(f"为了中奖我们需要摇{plays}次")
else:
	print(f"尝试{plays}次，没有中奖")
	print(f"你的彩票是：{new_ticket}")
	print(f"中奖彩票是：{winning_ticket}")
输出：
这是一张彩票
你的彩票是：[3, 4, 'b', 5]
中奖彩票是：['b', 5, 3, 4]
为了中奖我们需要摇2600次
[Finished in 0.6s]

为了理解下这个题的逻辑问题，把所有函数改成中文，结果更乱了，也把代码附上吧

from random import choice

def 中奖彩票(随机生成):
	"""摇出中奖号码"""
	中奖彩票列表 = []

	#使用while循环避免重复
	while len(中奖彩票列表) < 4:
		随机产生号码 = choice(随机生成)
		if 随机产生号码 not in 中奖彩票列表:
			中奖彩票列表.append(随机产生号码)
	return 中奖彩票列表

def 核对彩票(随机生成彩票列表, 中奖彩票列表):
	#检查彩票号码，在不在中奖组合里，只要有1个不是都返回假False。
	for 单个号码 in 随机生成彩票列表:
		if 单个号码 not in 中奖彩票列表:
			return False 
	return True

def 随机_生成_彩票(随机生成):
	"""随机生成彩票"""
	彩票列表 = []
	while len(彩票列表) < 4:
		随机产生号码 = choice(随机生成)
		if 随机产生号码 not in 彩票列表:
			彩票列表.append(随机产生号码)
	return 彩票列表


随机生成 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'a', 'b', 'c', 'd','e']
中奖彩票列表 = 中奖彩票(随机生成)


摇号次数 = 0
赢得 = False
最多摇号次数 = 1_000_000

while not 赢得:
	新_彩票 = 随机_生成_彩票(随机生成)
	赢得 = 核对彩票(新_彩票, 中奖彩票列表)
	摇号次数 += 1
	if 摇号次数 >= 最多摇号次数:
		break

if 赢得:
	print("这是一张彩票")
	print(f"你的彩票是：{新_彩票}")
	print(f"中奖彩票是：{中奖彩票列表}")
	print(f"为了中奖我们需要摇{摇号次数}次")
else:
	print(f"尝试{plays}次，没有中奖")
	print(f"你的彩票是：{新_彩票}")
	print(f"中奖彩票是：{中奖彩票列表}")

扩展学习：
一个双色球随机代码。使用了 sys ， time 标准库

from random import choice
import time
from showprocess import ShowProcess
"""双色球"""
print("开始载入33个红色号码")
time.sleep(1)
if __name__=='__main__':
    max_steps = 100
    process_bar = ShowProcess(max_steps, '载入完成！')
    for i in range(max_steps):
        process_bar.show_process()
        time.sleep(0.05)

print("\n现在开始摇动红色号码......")
red_number = list(range(1, 34))
winning_red_number = []
while len(winning_red_number) < 6:
	time.sleep(1)
	red_wobble = choice(red_number)
	if red_wobble not in winning_red_number:
		print(f"摇出 {red_wobble} 放入奖池")
		winning_red_number.append(red_wobble)

print(f"摇出红球号码是{winning_red_number}")

print("\n开始载入16个蓝色号码")
time.sleep(1)
if __name__=='__main__':
    max_steps = 100
    process_bar = ShowProcess(max_steps, '载入完成！')
    for i in range(max_steps):
        process_bar.show_process()
        time.sleep(0.05)

print("\n开始摇动蓝色号码......")

blue_number = list(range(1, 17))
winning_blue_number = []
while len(winning_blue_number) < 1:
	time.sleep(1)
	blue_wobble = choice(blue_number)
	if blue_wobble not in winning_blue_number:
		print(f"摇出蓝色号码 {blue_wobble} 放入奖池")
		winning_blue_number.append(blue_wobble)

print(f"摇出蓝色号码是{winning_blue_number}")

wobble = f"{sorted(winning_red_number)}{winning_blue_number}"
time.sleep(2)
print("-------------------------------------------------------")
print(f"本次随机产生的双色球号码为：{wobble}")

输出：
开始载入33个红色号码
[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]100.00%
载入完成！

现在开始摇动红色号码......
摇出 31 放入奖池
摇出 9 放入奖池
摇出 1 放入奖池
摇出 18 放入奖池
摇出 33 放入奖池
摇出 19 放入奖池
摇出红球号码是[31, 9, 1, 18, 33, 19]

开始载入16个蓝色号码
[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]100.00%
载入完成！

开始摇动蓝色号码......
摇出蓝色号码 2 放入奖池
摇出蓝色号码是[2]
-------------------------------------------------------
本次随机产生的双色球号码为：[1, 9, 18, 19, 31, 33][2]