name = input('please enter your name:')
print('hello,', name)
print('please input:')
a = int(input())
if a > 0:
print(a)
else:
print(-a)
print("I'm OK")
print("I\'m OK")
print('\\\n\\')
print('\\\t\\')
print(r'\\\t\\')
print('''line1
line2
line3''')
#输出结果为：
I'm OK
I'm OK
\
\
\ \
\\\t\\
line1
line2
line3
转义字符 \ 可以转义很多字符，比如 \n 表示换行， \t 表示制表符，字符 \本身也要转义，所以 \ 表示的字符就是
用 r'' 表示 '' 内部的字符串默认不转义
当表示多行内容的时候用三个单引号
变量本身不固定的语言称之为动态语言，也就是说变量可以重复赋值。而与之对应的就是静态语言，静态语言在定义变量的时候必须指定变量类型，如果赋值的时候类型不匹配就会报错。与静态语言相比，动态语言更灵活。
print(ord('A'))
print(ord('a'))
print(ord('中'))
print(chr(66))
print(chr(25991))
65
97
20013
B
文
print(len('ABC'))
print(len('中文'))
print(len(b'ABC'))
print(len(b'\xe4\xb8\xad\xe6\x96\x87'))
print(len('中文'.encode('utf-8')))
3
2
3
6
6
len() 函数计算的是 str 的字符数，如果换成 bytes ， len() 函数就计算字节数。
1 个中文字符经过 UTF-8 编码后通常会占用 3 个字节，而 1 个英文字符只占用 1 个字节。
# -*- coding: utf-8 -*-
该注释是为了告诉 Python 解释器，按照 UTF-8 编码读取源代码，否则，在源代码中写的中文输出可能会有乱码。
print('Hello,%s' % 'world')
print('%2d-%02d' % (3, 1))
print('%.2f' % 3.1415926)
print('Age: %s. Gender: %s' % (25, True))
print('growth rate: %d %%' % 7)
Hello,world
3-01
3.14
Age: 25. Gender: True
growth rate: 7 %
如果不太确定应该用什么， %s 永远起作用，它会把任何数据类型转换为字符串。
classmates = ['Michael', 'Bob', 'Tracy']
print(len(classmates))
print(classmates[0])
print(classmates[1])
print(classmates[2])
print(classmates[-1])
classmates.append('Adam')
print(classmates)
classmates.insert(1, 'Jack')
print(classmates)
print(classmates.pop())
print(classmates)
print(classmates.pop(1))
print(classmates)
classmates[1] = 'Sarah'
print(classmates)
3
Michael
Bob
Tracy
Tracy
['Michael', 'Bob', 'Tracy', 'Adam']
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
Adam
['Michael', 'Jack', 'Bob', 'Tracy']
Jack
['Michael', 'Bob', 'Tracy']
['Michael', 'Sarah', 'Tracy']
tuple 和 list 非常类似，但是 tuple 一旦初始化就不能修改。
不可变的 tuple 有什么意义？因为 tuple 不可变，所以代码更安全。如果可能，能用 tuple 代替 list 就尽量用 tuple。
只有 1 个元素的 tuple 定义时必须加一个逗号 , ，来消除歧义。这是因为括号 () 既可以表示 tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python 规定，这种情况下，按小括号进行计算。
虽然元组的内容不可变，但是当元组中包含列表的时候列表的内容是可变的，要创建一个内容也不变的 tuple 怎么做？那就必须保证 tuple 的每一个元素本身也不能变。
dict&set&不可变对象
相对于list,dict的查找方式类似于字典的索引查找，所以较快。
将数据放入dict时，除了初始化指定的方法外，还可以通过key放，后放的会把前面的冲掉。如果查找的时候key不存在，dict就会报错。
要删除一个一个key，使用pop，对应的value也会被删除。
set 和 dict 类似，也是一组 key 的集合，但不存储 value。 由于 key 不能重复，所以，在 set 中，没有重复的 key。
set 是有序的，重复元素在 set 中自动被过滤。通过 add(key) 方法可以添加元素到 set 中，可以重复添加，但不会有效果。通过 remove(key) 方法可以删除元素。set 可以看成数学意义上的无序和无重复元素的集合，因此，两个 set 可以做数学意义上的交集、并集等操作。
位置参数
def power(x, n):
s = 1;
while n > 0:
n = n - 1
s = s * x
return s
print(power(5, 2))
print(power(5, 3))
25
125
power(x,n)函数有两个参数x和n，这两个参数都是位置参数，调用函数的时候，传入的两个值依次按照位置顺序赋给参数x和n。
默认参数
def power(x, n=2):
s = 1;
while n > 0:
n = n - 1
s = s * x
return s
print(power(5))
25
这里将第二个参数n的默认值设定为2，调用power(5)的时候相当于调用了power(5,2)，但是当n不为2的时候就必须明确地传入n，比如power(5,3)。据此，设置默认参数可以简化函数地调用，但是有几点需要注意：一是必选参数在前，默认参数在后，否则python的编译器会报错。 二是当函数有多个参数的时候，把变化大的参数放在前面，变化小的参数放在后面而且可以当作默认参数，这样就能最大限度地降低调用函数的难度。
默认参数中的坑
可变参数
可变参数顾名思义就是传入的参数个数是可变的，是任意的。
第一想法是将输入的参数组合成一个list或者tuple，如下：
def calc(numbers):
sum = 0
for n in numbers:
sum = sum + n*n
return sum
print(calc([1, 2, 3]))
print(calc((1, 2, 3)))
14
14
下面利用可变参数的方式可以简化上述方式：
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n*n
return sum
print(calc(1, 2, 3))
print(calc(1, 2, 3))
运行结果是和上面一样的。
当已经有一个list或者tuple时，调用一个可变参数可以采用以下两种方式，其中第一种较为繁琐，而第二种是python允许在list或tuple前面加一个*号，把list或者tuple的元素变成可变参数传进去。
nums = [1, 2, 3]
print(calc(nums[0], nums[1], nums[2]))
print(calc(*nums))
运行结果仍然和上面的一致。
关键字参数
可变参数允许你传入 0 个或任意个参数，这些可变参数在函数调用时自动组装为一个 tuple。而关键字参数允许你传入 0 个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个 dict 。
def person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)
print(person('Michael', 30))
print(person('Bob', 35, city='Beijing'))
print(person('Adam', 45, gender='M', job='Engineer'))
name: Michael age: 30 other: {}
0
name: Bob age: 35 other: {'city': 'Beijing'}
0
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
0
关键字参数有什么用？它可以扩展函数的功能。比如，在 person 函数里，我们保证能接收到 name 和 age 这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。
同时，和可变参数类似，也可以先组装出一个dict，然后把该dict转换为关键字参数传进去，方法也有两种，其中第一种较为繁琐，第二种更加简洁：
extra = {'city': 'Beijing', 'job': 'Engineer'}
print(person('Jack', 24, city=extra['city'], job=extra['job']))
print(person('Jack', 24, **extra))
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
None
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
None
**extra 表示把 extra 这个 dict 的所有 key-value 用关键字参数传入到函数的 kw 参数， kw 将获得一个 dict，注意 kw 获得的 dict 是 extra 的一份拷贝，对 kw 的改动不会影响到函数外的 extra。
命名关键字参数
参数组合
