fruits= ['apple','banana','orange']
print fruits

#访问某个元素
print(fruits[0].title())

#Python中将索引指向-1，可访问最后一个元素,这种索引页适合其他的负索引，如-2表示倒数第二个元素，-3表示导出
第3个元素
print fruits[-1]

# 修改
fruits[0]='tomato'


# 添加,append()方法将元素加到末尾而不影响其它元素
fruits.append('apple')


# append()方法让动态创建数组变得十分容易，可先创建一个空数组，再动态添加数据
nums = []
nums.append('1')
nums.append('3')


# 插入，使用insert(),可以在列表任意位置插入数据
nums.insert(1,'2')


# 删除，del删除，前提：知道要删除的元素在列表中的位置
del nums[0]


# 删除，pop()删除---后进先出，从列表中弹出最后一个元素
fruits= ['apple','banana','orange']
print fruits
poped_fruits = fruits.pop()
print fruits
print poped_fruits


# 弹出列表中任何位置的元素，可以用pop()来弹出列表中任意位置的元素，只需要在括号中传要弹出元素的索引
poped_fruits = fruits.pop(1)


# 说明，如果你要从列表删除一个元素，且不再以任何方式使用它，就使用del语句；如果你要在删除元素后还能继续
用它，就使用方法pop()。


# 根据值删除元素，remove(),remove只删除第一个指定的值，如果要删除的值在列表中出现多次，俺就需要循环判断
来删除
fruits.remove('orange')

# sort()方法，永久排序,永久性修改列表元素排序，不可恢复到原来的排序
fruits= ['tomato','apple','banana','orange']
fruits.sort()
print fruits
fruits.sort(reverse=True)#按字母表逆序排


# sorted()，临时排序，sorted()让你能够按特定顺序显示列表元素，同时不影响它们在列表中的原始排列顺序，逆序
排列，传递参数reverse=True
fruits= ['tomato','apple','banana','orange']
fruits_sorted = sorted(fruits)
print fruits
print fruits_sorted
fruits_sorted = sorted(fruits,reverse=True)


# 倒着打印列表
fruits= ['tomato','apple','banana','orange']
fruits.reverse()
print fruits

fruits= ['tomato','apple','banana','orange']
len(fuits)

fruits= ['tomato','apple','banana','orange']
for f in fruits:
	print f

# 打印一系列数字in range(),注意in range()是前闭后开的
for i in range(1,5):
	print i


# 使用range()创建数字列表
nums = list(range(1,6))
print nums


# 使用函数range()时，还可指定步长,打印1-10内所有的偶数
nums = list(range(2,11,2))
print nums


# 使用range()几乎能实现所有的数字集，如下为1-10的乘方
squares = []
for i in range(1,11):
	square = i**2
	squares.append(square)
print squares


# 对数字列表执行简单的统计计算min()/max()/sum()
min(squares)
max(squares)
sum(squares)


#要使用下面这种语法，首先指定一个描述性的列表名，如squares；然后，指定一个左方括号，并定义一个表达式，用
于生成你要存储到列表中的值。在这个示例中，表达式为value**2，它计算平方值。接下来，编写一个for循环，用于给
表达式提供值，再加上右方括号
squares = [value**2 for value in range(1,11)]

# 要创建切片，可指定要使用的第一个元素和最后一个元素的索引。 与函数range()一样
fruits= ['tomato','apple','banana','orange']
print fruits[0:2]
print fruits[1:3]


# 如果没有指定第一个索引，Python将自动从列表开头开始
print fruits[:3]


# 不指定第二个索引，则切片终止于列表末尾
print fruits[2:]


# 可以使用负索引，打印列表末尾元素，如下打印后3个
print fruits[-3:]

fruits= ['tomato','apple','banana','orange']
for f in fruits[:3]:
	print f

# 复制列表原理，创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引（[:]）
my_fruits= ['tomato','apple','banana','orange']
your_fruits = my_fruits[:]

#元组看起来犹如列表，但使用圆括号而不是方括号来标识
bytime = ('year','month','day')
print bytime[0]
print bytime[1]

for t in bytime:
	print t

# 虽然不能修改元组的元素，但可以给存储元组的变量赋值。因此，可通过重新定义整个元组来修改元组变量
bytime = ('year','month','day')
bytime = ('year','month','day','hour','minite','second')

# 检查是否相等
car = 'Bwt'
car == 'bwt'# 考虑大小写
car.lower() == 'bwt'#不考虑大小写


# 检查是否不相等
car = 'Bwt'
if(car != 'Audio'):
	print 'error'


# 比较数字  >  <  >=  <=  ==
# 多个条件检查
# and ：与关系
# or：或关系


# 检查特定值是否包含在列表中，可以用in实现
bytime = ('year','month','day')
bytimes = ['yy','mm','dd']
'years' in bytime
'years' in bytimes


# 检查特定值是否不包含在列表中，not in
bytime = ('year','month','day')
'years' not in bytime

# 最简单的if
if conditional_test:
	do something


# if-else
age = 17
if age > 18:
	print '未成年'
else:
	print '已成年'


# if-elif-else
age = 12
if age < 4:
   print("Your admission cost is $0.")
elif age > 18:
   print("Your admission cost is $5.")
else:
   print("Your admission cost is $10.")


# 使用多个elif
age = 12
if age < 4:
   price = 0
elif age < 18:
   price = 5
elif age < 65:
   price = 10
else:
   price = 5
print("Your admission cost is $" + str(price) + ".")


# 省略else代码块，else是一条包罗万象的语句，只要不满足任何if或elif中的条件测试，其中的代码就会执行，可能
会引入无效甚至恶意的数据。

# 测试多个条件,多个if连续判断

# 检查特殊元素
fruits = ['tomato','apple','banana','orange']
for fruit in fruits:
	if fruit == 'apple':
		print 'sorry ,we are out of '+ fruit + 'now'
	else:
		print 'buy'+ fruit


# 确定列表不是空的
fruits = []
if fruits :
	for fruit in fruits:
		print 'buy'+ fruit
else:
	print 'buy nothing'


# 使用多个列表
avilable_fruit = ['apple
','banana','orange']
buy_fruit= ['tomato','apple']
for buy in buy_fruit:
	if buy in avilable_fruit:
		print ('buy '+buy)
	else:
		print ('sorry ,we are out of '+ buy + 'now')

stu={'name':'zhangsan','age':18,'class':'test'}

print (stu['name'])

stu['addr']='湖北武汉'
stu['work']='Tester'

stu={'name':'zhangsan','age':18,'class':'test'}
stu['age']=20

stu={'name':'zhangsan','age':'18,'class':'test'}
del stu['class']#注意删除的键值对永远消失了

#遍历所有键值对
stu={'name':'zhangsan','age':'18','class':'test'}
for key,value in stu.items():
	print('\nkey: '+key)
	print('value: '+value)


# 遍历所有键
stu={'name':'zhangsan','age':18,'class':'test'}
for key in stu.keys():
	print('\nkey: '+key)


# 遍历字典时，会默认遍历所有的键，因此，如果将上述代码中的for key in stu.keys():替换为for key in stu:，
输出将不变。


# 方法keys()并非只能用于遍历,实际上，它返回一个列表，其中包含字典中的所有键
if 'class' not in stu.keys():
	print(stu['name']+'已经毕业')


# 按顺序遍历字典中所有键
stu={'name':'zhangsan','age':18,'class':'test'}
for key in sorted(stu.keys()):
	print('\nkey: '+key)


# 遍历字典中的所有值
intersts={'张珊':'sing','李思':'dance','王武':'sing','赵流':'write'}
for value in intersts.values():
	print('\nvalue: '+value)


# 通过对包含重复元素的列表调用set()，可让Python找出列表中独一无二的元素，并使用这些元素来创建一个集合
intersts={'张珊':'sing','李思':'dance','王武':'sing','赵流':'write'}
for value in set(intersts.values()):
	print('\nvalue: '+value)

# 字典列表
stu_1 = {'name':'zhangsan','age':'18','grade':'72'}
stu_2 = {'name':'lisi','age':'20','grade':'90'}
stu_3 = {'name':'wangwu','age':'17','grade':'80'}
stu_list = [stu_1,stu_2,stu_3]
for stu in stu_list:
	print (stu)


aliens = []
# 创建30个绿色的外星人
for alien_number in range(30):
	new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}
	aliens.append(new_alien)
# 显示前五个外星人
for alien in aliens[:5]:
	print(alien)
print("...")


# 显示创建了多少个外星人
print("Total number of aliens: " + str(len(aliens)))


# 将前三个外星人修改为黄色的、速度为中等且值10个点
for alien in range[:3]:
	if alien['color'] == 'green':
		alien['color']= 'red'
		alien['points'] = 10
		alien['speed']='medium'
		print alien


# 在字典中存储列表
goods ={'zhangsan':['sing','dance'],'lisi':['look book','have foods'],'wangwu':['write','sports']}
for name,good in goods.items():
	print (name + "'s goods are:")
	for g in good:
		print (g)


# 在字典中存储字典
grades = {'zhangsan':{'english':'80','math':'90','chinese':'72'},'lisi':{'english':'82','math':'70','chinese':'92'}}
for name,grade in grades.items():
	print (name + "'s grades are :")
	for sub,score in grade.items():
		print (sub + ":" + score)

msg = input("请输入你喜欢的数字")
print (msg +"是个很美妙的数字")

msg = raw_input("请输入你喜欢的数字")
print (msg +"是个很美妙的数字")

7%3

# 条件不满足退出
num = 1
while num <=5:
	print (num)
	num += 1


# 用户自己选择何时退出
msg = ''
while msg != 'quit':
	msg = input('tell me something')
	if msg != 'quit':
		print (msg)


# 使用标识控制程序结束
flag = True
while flag:
	msg = input('input something')
	if msg == 'quit':
		flag = False
	else:
		print (msg)


# 使用break退出循环
while True:
	msg = input('input something')
	if msg == 'quit':
		break
	else:
		print ('I love ' + msg)


# 在循环中使用continue
num = 0
while num <10:
	num += 1
	if num % 2 == 0:
		continue
	print (num)


# while循环来处理列表和字典
# 将补考通过的学员加入通过学员列表中
stu_fail = ['xiaoming','qingqing','dongdong']
stu_pass = []
while stu_fail:
	passstu = stu_fail.pop()
	print ('恭喜'+passstu+'补考通过')
	stu_pass.append(passstu)
print (stu_pass)


# 删除列表中包含的某元素（全删，并不是只删除第一个）
test= ['dog','cat','pig','dog','mouse','dog']
while 'dog' in test:
	test.remove('dog')
print (test)


# 使用用户输入来填充字典
response = {}
flag = True
while flag:
	name = input('what is your name ?')
	res = input('what is intersting ?')
	response[name] = res
	ismore = input('do you want to others ,yes or no ? ')
	if ismore == 'no':
		flag = False
print (response)

# 所有补考的学员考完后移动到通过人员列表中
def haveexam(all,passstus):
	while all:
		current = all.pop()
		print (current + 'is having the exam !')
		passstus.append(current)

def passstu(psslist):
	for stu in psslist:
		print (stu + 'has pass the exam !')

stus = ['xiaoming','xiaohua','honghong']
pass_stu = []
haveexam(stus,pass_stu)
passstu(pass_stu )

# 上述学员通过后，会从原来的补考列表中删除，要想原来的补考列表仍保留，可通过传递备份实现
stus = ['xiaoming','xiaohua','honghong']
stus_bak = stus[:]
pass_stu = []
haveexam(stus_bak,pass_stu)
passstu(pass_stu )

# 传递任意数量实参
# *fruits,创建一个名为fruits的空元组，，并将收到的所有值都封装到这个元组中，将实参封装到一个元组中，即便
函数只收到一个值也如此
def shopping(*fruits):
	for fruit in fruits:
		print ('add ' + fruit + 'to order list')

shopping('apple','orange','banana')


# 结合使用位置实参和任意数量实参
def shopping(counts ,*fruits):
	print ('I have '+counts + ' yuan .I can buy : ')
	for fruit in fruits:
		print (fruit)

shopping('10','apple','orange','banana')

# 使用任意数量的关键字参数
def get_user_info(firname,lastname,**otherinfo):
	user_info = {}
	user_info['firstnam']= firname
	user_info['lastname']= lastname
	for key,value in otherinfo.items():
		user_info[key]= value
	return user_info

stu_info = get_user_info('zhang','san',age=12,grade='one')
print (stu_info)

class Dog():
	def __init__(self,name,age):
		self.name = name
		self.age = age

	def sit(self):
		print (self.name + 'is sitting')

	def roll_over(self):
		print (self.name + 'is rolling ,and its age is '+ str(self.age))

dog = Dog('jack',18)
dog.sit()
dog.roll_over()


# 在Python 2.7中创建类时，需要做细微的修改——在括号内包含单词object
class ClassName(object):

class Car():
	def __init__(self, name, model, year):
		self.name = name
		self.medel = model
		self.year = year
		self.runlength = 0


	def get_fullname(self):
		ful = str(self.year) + ',' + self.name + ',' + self.medel
		print(ful)
		return ful


	def update_run(self, mil):
		if mil >= self.runlength:
			self.runlength = mil
		else:
			print('you can not run back length')


	def increce_run(self, addmil):
		self.runlength += addmil


class ElecCar(Car):
	def __init__(self, name, model, year):
		super().__init__(name, model, year)


my_elec_car = ElecCar('Audi', 'Q4', 2013)
my_elec_car.get_fullname()
my_elec_car.update_run(10)
my_elec_car.increce_run(20)
print(str(my_elec_car.runlength))


# 在Python 2.7中，继承语法稍有不同,函数super()需要两个实参：子类名和对象self
class ElectricCar(Car):
    def __init__(self, make, model, year):
		super(ElectricCar, self).__init__(make, model, year)

class ElecCar(Car):
	def __init__(self, name, model, year):
		super().__init__(name, model, year)
		self.color = 'red'

	def print_color(self):
		print('my color is '+ self.color)

class Car():
	def __init__(self, name, model, year):
		self.name = name
		self.medel = model
		self.year = year
		self.runlength = 0

	def get_fullname(self):
		ful = str(self.year) + ',' + self.name + ',' + self.medel
		print(ful)
		return ful

	def update_run(self, mil):
		if mil >= self.runlength:
			self.runlength = mil
		else:
			print('you can not run back length')

	def increce_run(self, addmil):
		self.runlength += addmil

	def to_write(self):
		print ('i am father')


class ElecCar(Car):
	def __init__(self, name, model, year):
		super().__init__(name, model, year)
		self.color = 'red'

	def print_color(self):
		print('my color is ' + self.color)

	def update_run(self):
		print('hhh')

	def to_write(self):
		print ('i am sun')


my_elec_car = ElecCar('Audi', 'Q4', 2013)
my_elec_car.get_fullname()
my_elec_car.update_run()
my_elec_car.increce_run(20)
print(str(my_elec_car.runlength))
my_elec_car.print_color()
my_elec_car.to_write()


# update_run()和to_write()都是重写父类方法，在子类中定义一个与父类同名的方法，参数可不同，Python将不会考
虑父类的这个方法，而只关注子类中定义的相应方法

class Car():
	def __init__(self, name, model, year):
		self.name = name
		self.medel = model
		self.year = year
		self.runlength = 0

	def get_fullname(self):
		ful = str(self.year) + ',' + self.name + ',' + self.medel
		print(ful)
		return ful

	def update_run(self, mil):
		if mil >= self.runlength:
			self.runlength = mil
		else:
			print('you can not run back length')

	def increce_run(self, addmil):
		self.runlength += addmil

	def to_write(self):
		print ('i am father')

class CarAttr():
	def __init__(self,color='red',size=4):
		self.color =color
		self.size = size

	def print_color(self):
		print('my color is '+ self.color)

	def print_size(self):
		print('my color is ' + str(self.size))

class ElecCar(Car):
	def __init__(self, name, model, year):
		super().__init__(name, model, year)
		self.attr = CarAttr()

	def update_run(self):
		print('我是重写的方法')

	def to_write(self):
		print ('i am son')


my_elec_car = ElecCar('Audi', 'Q4', 2013)
# 调用父方法
my_elec_car.get_fullname()
my_elec_car.increce_run(20)
print(str(my_elec_car.runlength))
# 调用重写的方法
my_elec_car.update_run()
my_elec_car.to_write()
# 将实例用作属性定义的方法
my_elec_car.attr.print_size()
my_elec_car.attr.print_color()

# 导入单个类：
from car import Car

# 从一个模块中导入多个类：
from car import Car, ElectricCar

# 导入整个模块：
import car

# 导入模块中的所有类,不推荐，需要从一个模块中导入很多类时，最好导入整个模块，并用module_name.class_name
语法来访问类:
from module_name import *

from collections import OrderedDict
favarite_fruit = OrderedDict()
favarite_fruit['xiaodong']='apple'
favarite_fruit['xiaoxi']='pear'
favarite_fruit['xiaonan']='banana'
favarite_fruit['xiaobei']='orange'
for name,fruit in favarite_fruit.items():
	print(name + "'s favarite fruit is " + fruit)

# open()要以任何方式使用文件都得先打开文件,哪怕仅仅是打印其内容
# 关键字with在不再需要访问文件后将其关闭
# 在文件路径中使用反斜杠（\）而不是斜杠（/）
with open ('D:/pythontest/pi_digits.txt') as file:
	# 读取文件全部内容
	contents = file.read()
	# read()到达文件末尾时返回一个空字符串，而将这个空字符串显示出来时就是一个空行。
	print (contents)
	# 要删除多出来的空行，可在print语句中使用rstrip()：
	print (contents.rstrip())

filepath= 'D:/pythontest/pi_digits.txt'
with open(filepath) as file:
	for line in file:
		print (line.rstrip())

filepath= 'D:/pythontest/pi_digits.txt'
with open(filepath) as file:
	# 从文件中读取每一行，并将其存储在一个列表中
	lines = file.readlines()

for line in lines:
	print (line)

filepath= 'D:/pythontest/pi_digits.txt'
with open(filepath) as file:
	# 从文件中读取每一行，并将其存储在一个列表中
	lines = file.readlines()
pi= ''
for line in lines:
	pi += line.strip()
print (pi)
print(len(pi))

filepath= 'D:/pythontest/pi_digits.txt'
with open(filepath) as file:
	# 从文件中读取每一行，并将其存储在一个列表中
	lines = file.readlines()
pi= ''
for line in lines:
	pi += line.strip()


# 保留10位
print (pi[:10]+'...')

filepath= 'D:/pythontest/write.txt'
# 已写入方式打开文件
with open(filepath,'w') as file:
	# 这种方式写入文件会直接覆盖掉文件原有内容，并不是追加写
	file.write('test')

filepath= 'D:/pythontest/write.txt'
# 已写入方式打开文件
filepath= 'D:/pythontest/write.txt'
with open(filepath,'w') as file:
	# 这种方式写入文件会直接覆盖掉文件原有内容，并不是追加写
	file.write('line one \n')
	file.write('line two \n')

filepath= 'D:/pythontest/write.txt'
with open(filepath,'a') as file:
	# 这种方式写入文件会直接覆盖掉文件原有内容，并不是追加写
	file.write('line three \n')
	file.write('line four\n')

try:
	print(5/0)
except ZeroDivisionError:
	print ('you can not devide by zero')

# try-except-else工作原理：只有可能引发异常的代码才需要放在try语句中,仅在try代码块成功执行时才需要运行的
代码应放在else代码块中。except代码块指示try代码块运行出现了异常该怎么办。
print('give me two number and i will tell you the division result to you')
print("press 'q' to quit")

while True:
	fir_num = input('the first number')
	if fir_num == 'q':
		break
	sec_num = input('the second number')
	if sec_num == 'q':
		break
	try:
		result = int(fir_num)/int(sec_num)
	except Exception as e:
		print(e)
	else:
		print (result)

filepath = 'D:/pythontest/test.txt'
try:
	with open(filepath) as file:
		contents = file.read()
except FileNotFoundError:
	print(filepath+' not exsit')
else:
	print(contents)

filepath = 'D:/pythontest/write.txt'
try:
	with open(filepath) as file:
		contents = file.read()
except Exception as e:
	print('something error,the detail into is : '+e)
else:
	words = contents.split(' ')
	words_len = len(words)
	print (words)
	print('total num is :'+ str(words_len))

def count_book(filepath):
	try:
		with open(filepath) as file:
			contents = file.read()
	except Exception as e:
		print( e)
	else:
		words = contents
		words_len = len(words)
		print (words)
		print( 'total num is :' + str(words_len))

books = ['D:/pythontest/write.txt' ,'D:/pythontest/1.txt' ,'D:/pythontest/2.txt','D:/pythontest/3.txt']
for book in books:
	count_book(book)

# json.dump(),将数字列表存储到json文件中
import json
nums = [1,2,3,4,5]
file = 'D:/pythontest/3.txt'
with open(file,'w') as file_obj:
	json.dump(nums,file_obj)


# json.load(),将列表读取到内存
import json
filepath = 'D:/pythontest/3.txt'
with open(filepath) as file_obj:
	nums = json.load(file_obj)
	print (nums)


# 保存和读取用户生成的数据
import json
username = input('tell me your name and i will remember it :')
filepath = 'D:/pythontest/username.txt'
with open(filepath,'w') as file_obj:
	json.dump(username,file_obj)
	print('i have remember your name,'+username)



import json
filepath = 'D:/pythontest/username.txt'
try:
	with open(filepath) as file_obj:
		username = json.load(file_obj)
		print('welcome bace '+ username)
except FileNotFoundError:
	with open(filepath,'w') as file_obj:
		username = input('tell me your name and i will remember it :')
		json.dump(username,file_obj)
		print('i have remember your name,'+username)