# -*- coding:utf-8 -*-
__author__ = 'hunterhug'
#x = int(input("请输入一个数:\n"))
x=5
if x < 0:
print("<0")
elif x == 0:
print("0")
else:
print(">0")
str=['fds', 'sdfsdf', '2',"h"]
for k in str:
print(k, len(k))
#在迭代过程中修改迭代序列不安全
# （只有在使用链表这样的可变序列时才会有这样的情况）。
# 如果你想要修改你迭代的序列（例如，复制选择项），
# 你可以迭代它的复本。使用切割标识就可以很方便的做到这一点:
for x in str[:]:
if len(x) > 1: str.insert(0,x)
print(str)
print(x)
for k in range(5):
print(k)
#range(10) 生成了一个包含 10 个值的链表，
# 它用链表的索引值填充了这个长度为 10 的列表，
# 所生成的链表中不包括范围中的结束值。也可以让 range() 操作从另一个数值开始，
# 或者可以指定一个不同的步进值（甚至是负数，有时这也被称为 “步长”）:
print(range(5, 10))
# 5 through 9
print(range(0, 10, 3))
# 0, 3, 6, 9
print(range(-10, -100, -30))
# -10, -40, -70
#在不同方面 range() 函数返回的对象表现为它是一个列表，
# 但事实上它并不是。 当你迭代它时，它是一个能够像期望的序列返回连续项的对象；
# 但为了节省空间，它并不真正构造列表。
#我们称此类对象是 可迭代的 ，
# 即适合作为那些期望从某些东西中获得连续项直到结束的函数或结构的一个目标（参数）。
# 我们已经见过的 for 语句就是这样一个 迭代器 。
# list() 函数是另外一个（ 迭代器），它从可迭代（对象）中创建列表:
print(list(range(5)))
a = ['Mary', 'had', 'a', 'little', 'lamb']
for i in range(len(a)):
print(i, a[i])
for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
print(n, 'equals', x, '*', n//x)
break
else:
# loop fell through without finding a factor
print(n, 'is a prime number')
for num in range(2, 10):
if num % 2 == 0:
print("Found an even number", num)
continue
print("Found a number", num)
def initlog(*args):
pass # Remember to implement this!
a=0
def fib(n):
"""Print a Fibonacci series up to n."""
a, b = 0, 1
while a < n:
print(a, end=' ')
a, b = b, a+b
print()
# Now call the function we just defined:
fib(2000)
#函数 调用 会为函数局部变量生成一个新的符号表。
# 确切的说，所有函数中的变量赋值都是将值存储在局部符号表。
# 变量引用首先在局部符号表中查找，然后是包含函数的局部符号表，
# 然后是全局符号表，最后是内置名字表。
# 因此，全局变量不能在函数中直接赋值（除非用 global 语句命名），尽管他们可以被引用。
print(a) #a还是没变
#函数引用的实际参数在函数调用时引入局部符号表，
# 因此，实参总是 传值调用 （这里的 值 总是一个对象 引用 ，而不是该对象的值）。
# [1] 一个函数被另一个函数调用时，一个新的局部符号表在调用过程中被创建。
f=fib
print(f)
print(fib)
def fib2(n): # return Fibonacci series up to n
"""Return a list containing the Fibonacci series up to n."""
result = []
a, b = 0, 1
while a < n:
result.append(a) # see below
a, b = b, a+b
return result
print(fib2(100))
def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
while True:
ok = input(prompt)
if ok in ('y', 'ye', 'yes'):
return True
if ok in ('n', 'no', 'nop', 'nope'):
return False
retries = retries - 1
if retries < 0:
raise IOError('refusenik user')
print(complaint)
#ask_ok('n')
i = 5
def f(arg=i):
print(arg)
i = 6
f()
#默认值只被赋值一次。
# 这使得当默认值是可变对象时会有所不同，
# 比如列表、字典或者大多数类的实例。
# 例如，下面的函数在后续调用过程中会累积（前面）传给它的参数:
def f(a, L=[]):
print(L)
L.append(a)
return L
print(f(1))
print(f(2))
print(f(3))
#why?
def f(a, L=None):
print(L)
if L is None:
L = []
L.append(a)
return L
print(f(1))
print(f(2))
print(f(3))
def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
print("-- This parrot wouldn't", action, end='22 ')
print("if you put", voltage, "volts through it.")
print("-- Lovely plumage, the", type)
print("-- It's", state, "!")
parrot(1000) # 1 positional argument
parrot(voltage=1000) # 1 keyword argument
parrot(voltage=1000000, action='VOOOOOM') # 2 keyword arguments
parrot(action='VOOOOOM', voltage=1000000) # 2 keyword arguments
parrot('a million', 'bereft of life', 'jump') # 3 positional arguments
parrot('a thousand', state='pushing up the daisies') # 1 positional, 1 keyword
#引入一个形如 **name 的参数时，它接收一个字典（参见 typesmapping ） ，
# 该字典包含了所有未出现在形式参数列表中的关键字参数。
# 这里可能还会组合使用一个形如 *name （下一小节详细介绍） 的形式参数，
# 它接收一个元组（下一节中会详细介绍），
# 包含了所有没有出现在形式参数列表中的参数值。
# （ *name 必须在 **name 之前出现） 例如，我们这样定义一个函数:
def cheeseshop(kind, *arguments, **keywords):#元组 字典
print("-- Do you have any", kind, "?")
print("-- I'm sorry, we're all out of", kind)
for arg in arguments:
print(arg)
print("-" * 40)
keys = sorted(keywords.keys())
for kw in keys:
print(kw, ":", keywords[kw])
cheeseshop("Limburger", "It's very runny, sir.",
"It's really very, VERY runny, sir.",
shopkeeper="Michael Palin",
client="John Cleese",
sketch="Cheese Shop Sketch")
#任何出现在 *args 后的参数是关键字参数，这意味着，他们只能被用作关键字，而不是位置参数
def concat(*args, sep="/"):
return sep.join(args)
c=concat("earth", "mars", "venus")
print(c)
c1=concat('f','f',sep="dddd")
print(c1)
#另有一种相反的情况: 当你要传递的参数已经是一个列表，
# 但要调用的函数却接受分开一个个的参数值。
# 这时候你要把已有的列表拆开来. 例如内建函数 range() 需要要独立的 start , stop 参数.
# 你可以在调用函数时加一个 * 操作符来自动把参数列表拆开
args = [3, 6] #列表
a1=list(range(*args))
print(a1)
def parrot(voltage, state='a stiff', action='voom'):
print("-- This parrot wouldn't", action, end=' ')
print("if you put", voltage, "volts through it.", end=' ')
print("E's", state, "!")
d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}#字典
parrot(**d)#字典解包
#出于实际需要，有几种通常在函数式编程语言例如 Lisp 中出现的功能加入到了 Python 。
# 通过 lambda 关键字，可以创建短小的匿名函数。
# 这里有一个函数返回它的两个参数的和： lambda a, b: a+b 。
# Lambda 形式可以用于任何需要的函数对象。
# 出于语法限制，它们只能有一个单独的表达式。
# 语义上讲，它们只是普通函数定义中的一个语法技巧。
# 类似于嵌套函数定义，lambda 形式可以从外部作用域引用变量:
def make_incrementor(n):
"""ffffffffff
fff
f
f
f
f
f
fgg"""
return lambda x,y: x + n + y
f = make_incrementor(42)
print(make_incrementor.__doc__)
print(f.__doc__)
print(f(0,1))
print(f(1,5))
print(f(2,9))
#这里介绍的文档字符串的概念和格式。
#第一行应该是关于对象用途的简介。
# 简短起见，不用明确的陈述对象名或类型，因为它们可以从别的途径了解到（除非这个名字碰巧就是描述这个函数操作的动词）。
# 这一行应该以大写字母开头，以句号结尾。
#如果文档字符串有多行，第二行应该空出来，与接下来的详细描述明确分隔。接下来的文档应该有一或多段描述对象的调用约定、边界效应等。
#Python 的解释器不会从多行的文档字符串中去除缩进，
# 所以必要的时候应当自己清除缩进。这符合通常的习惯。
# 第一行之后的第一个非空行决定了整个文档的缩进格式。（
# 我们不用第一行是因为它通常紧靠着起始的引号，缩进格式显示的不清楚。）
# 留白“相当于”是字符串的起始缩进。每一行都不应该有缩进，
# 如果有缩进的话，所有的留白都应该清除掉。
# 留白的长度应当等于扩展制表符的宽度（通常是8个空格）。
def d():
"""http://www.mamicode.com/info-detail-241497.html
对于 Python， PEP 8 引入了大多数项目遵循的风格指导。它给出了一个高度可读，视觉友好的编码风格。每个 Python 开发者都应该读一下，大多数要点都会对你有帮助：
使用 4 空格缩进，而非 TAB。
在小缩进（可以嵌套更深）和大缩进（更易读）之间，4空格是一个很好的折中。TAB 引发了一些混乱，最好弃用。
折行以确保其不会超过 79 个字符。
这有助于小显示器用户阅读，也可以让大显示器能并排显示几个代码文件。
使用空行分隔函数和类，以及函数中的大块代码。
可能的话，注释独占一行
使用文档字符串
把空格放到操作符两边，以及逗号后面，但是括号里侧不加空格： a = f(1, 2) + g(3, 4) 。
统一函数和类命名。
推荐类名用 驼峰命名， 函数和方法名用 小写_和_下划线。总是用 self 作为方法的第一个参数（关于类和方法的知识详见 初识类 ）。
不要使用花哨的编码，如果你的代码的目的是要在国际化 环境。 Python 的默认情况下，UTF-8，甚至普通的 ASCII 总是工作的最好。
同样，也不要使用非 ASCII 字符的标识符，除非是不同语种的会阅读或者维护代码。
"""
pass
#http://docs.pythontab.com/python/python3.4/datastructures.html
