# 需求：
# 1. 系统随机出一个数字，用户需要猜是多少；
# 2. 需要反馈用户猜的数字是大了还是小了；
# 3. 用户只有3次猜测机会；

import random
key = random.randint(1, 10)

print('-----------Game Start-----------')
temp = input('guess a number between 1~10, you have 3 chances: ')
guess = int(temp)
i = 2

while (guess != key) and (i > 0):
	if guess > key:
		print('no no no, your number is bigger ~~~')
	else:
		print('no no no, your number is smaller ~~~')
	temp = input('guess again, you still have ' + str(i) + ' chance to guess: ')
	guess = int(temp)
	i -= 1

if guess == key:
	print('congras, you are right !')
else:
	print('oops, still wrong, what a pity')

print('-----------Game Over-----------')
print('')
print('the answer is: ' + str(key))

else:

print("握草，你是小黑猫心里的蛔虫吗？")

print("游戏结束，不玩啦~~")

if guess > 8:

print("嘿，小了！小了！！")

print("呵呵哒！猜中了也没有奖励！0.0")

if guess == 8:

print("哥，大了！大了！！")

print('----------------------黑猫工作室---------------------')
temp = input("猜猜黑猫内心在想啥：")
guess = int(temp)
if guess == 5:
    print("我擦，你是黑猫心中的蛔虫吗？www.heimaoba.top ！")
    print("呵呵哒！猜中了也没有奖励！0.0")
else:
    print("猜错啦0.0，黑猫内心想的是8！www.heimaoba.top！")
print("游戏结束，不玩啦！0.0 www.heimaoba.top")

1.变量——数字，字母，下划线
2.python没有变量只有名字
3.使用变量先赋值，
4.创建字符串单引号和双引号成对出现
5.转义字符“\”
6.原始字符串 使用反斜杠对自身转义。
7.原始字符串在英文字母前加上r.
注意：全部使用英文的标点符号。
 

__init__ 自动调用 自定义初始化操作

1.要么怎样，要么不怎样

ifelse

2.干完了能怎样，干不完就别想怎样

while／for else

3.没有问题，那就干吧

try except else

4.with 

1.global

2.内嵌函数，内部函数

内部函数整个作用域都在外部函数之内

3.闭包 如果在一个内部函数里，对外部作用域（但不是在全局作用域变量进行引用）内部函数认为是闭包

4.容器类型

5.nonlocal

1.行参

2.实参

3.函数文档，解释函数，通过help or __doc__查看

4.关键字参数，搞不清参数顺序

5.默认参数，初始值

6.收集参数（可变参数）＊params ->元组打包

重复反馈过程的活动，其目的通常是为了接近并达到所需目标或结果，每一次对过程重复称之为一次迭代，而每一次迭代得到的结果，都会被用来成为下一次迭代的初始值 。

1.位置参数

‘｛0｝’。format（）

2.关键字参数

‘｛a｝’。format（a=）

3.位置参数优先关键字参数

4.｛｛｝｝解释掉了，  第一层｛｝

5.字符串格式化

Python这么牛？

1.e记法：

>>> 1.5e11
150000000000.0

2.布尔类型bool：True(1),False(0)

3.类型转换

int()

float()

str()

4.获得类型

type()

isinstance():

>>> a='小甲鱼'
>>> isinstance(a,str)
True

python

跨平台

Windows、macos、linux

def factorial(n):

 if n==1:

   return 1

 else:

   return n * factorial(n-1)

number = int(input('请输入一个正整数')

result = factorial(number)

print("%d 的阶乘是：%d" % (number,result))

* 匿名函数 lambda

 例 ：>>> def ds(x)

          return 2 * x + 1

     等价于

     >>> lambad x : 2 * x + 1

* 两个牛逼的 bif

 1. filter() 过滤器

  例：将偶数过滤

 >>> def odd(x):

      return x % 2

 >>> temp = range(10)

 >>> show = filter(odd,temp)

 >>> list(show)

 [1,3,5,7,9] 

  或者写成：

list(fliter(lambda x:x%2,range(10)))

2.. map() 变形

例：list(map(lambda x:x*2,range(10)))

   [0,2,4,6,8,10,12,14,16,18]

* 列表，元组和字符串的共同点

 -都可以通过索引得到每一个元素

 -默认索引值总是从0开始

 -可以通过分片的方法得到一个范围内的元素   的集合

 -有很多共同的操作符（重复操作符，拼接操作符，成员关系操作符）

* list() 把一个可迭代对象转换为列表

* max() 返回序列或者参数集合中的最大值

* min() 返回序列或者参数集合中的最小值

* sum(interable[,start=0]) 返回序列     interable和可选参数start的总和

* 元组（元素不可改变）

  元素之间的逗号是关键

  间接地删除，添加元素，用分片的思路

  例：temp=temp[:2]+('怡静')+temp[2:]

* count()

 表示ta的参数在列表中出现的次数

 例：list3.count(123)

* index()

 表示ta的参数在列表指定范围内的位置

 例：list3.index(123,3,7)

* reverse()

  表示将ta的参数逆序排列

  例：list3.reverse()

* sort()

  表示将ta的参数按指定方式排列，默认按   从小到大排列

  例：list6.sort()

* 从列表删除元素

    remove（）

 例：member.remove('怡静')

     del()

 例：del member[1]

     pop()

 例：member.pop(1)

* 列表分片（slice）

 利用索引值，每次可以从列表获取一个元素

 利用列表分片，每次可以从列表获取多个元  素

 例：member[1：3]

  注：从第一个参数的索引值开始，到第二      个参数（包含左不包含右），原列表      无变化

* 向列表中添加元素(一次添加一个）

     apppend()

例：member.append('福禄娃娃'）

* 向列表中添加元素（一次添加多个）

     extend()

例：member.extend(['竹林小溪','crazy迷恋'])

* 向列表中添加元素（插入）

      insert()

例：member.insert(1,'牡丹')

  第一个参数表示插入的位置，第二个参数   表示该参数