命令模式C:\>(需要进入相对路径才不会报错）
交互模式>>>
Python的文件后缀名必须以(file.py)结尾
//直接运行.py 文件，在Windows上是不行的，但是，在Mac和Linux上是可以的，方法是在.py文件的第一行加上一个特殊的注释： #!/usr/bin/env python3 print('hello, world')
print()会依次打印每个字符串，遇到逗号“,”会输出一个空格
print('100+200=',100+200)需要，隔开
语句块一般为4个空格缩进
\\表示的字符就是\
print('I\'m \"OK\"!')#后面有特殊字符，需要转义符\
I'm "OK"!
' 和" 输入字符串
'''多行''' r对''' '''没有干扰
ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符
str='ABC' #字符串
x =b'ABC' #bytes
如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法：
len()#字符数
如果换成bytes，len()函数就计算字节数：>>> len('中文'.encode('utf-8'))
6中文字符 -3个 英文字符-1个字节
Python文件开头写，注明编码格式utf-8
#!/usr/bin/env python3
这行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；
# -*- coding: utf-8 -*-
第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。
>>> 'growth rate: %d %%' %7
growth rate: 7 %'
'Hello, %s成绩提升了%.1f %%' %('小明', 13/75)
list:有序的集合
list是一种有序的集合，可以随时添加和删除其中的元素。
list=['li','liu','wang']
len(list)
list[0];list[-1] indexError索引越界
有序添加list.append("san")集合的末尾
list.insert(2，"jack")#插入到指定位置
list.pop()删除末尾元素
list.pop(i)删除指定元素
list[2]="javah"#替换指定值
list=["xiao",123,["小明",12],true]
空的list，长度为0；list[]
tuple: 有序的元组
但是tuple一旦初始化就不能修改，没有添加，替换，删除元素操作，它更安全，
空的tuple()
一个tuple定义 tuple(1,)消除歧义；
tuple指向不变，指向一个list就不能改编成其他对象，但是指向的list本身是可以变得
p=（"A","B",["x","y"],"C"）
p[2][0]="M"
p[2][1]="D"
p=("A","B",["M","D"],"C")
L = [
['Apple','Google','Microsoft'] ,
['Java','Python','Ruby','PHP'] ,
['Adam','Bart','Lisa']
]
# 打印Apple:
print(L[0][0])
# 打印Python:
print(L[1][1])
# 打印Lisa:
print(L[2][2])
if条件判断语句:elif是else if的缩写，完全可以有多个elif，所以if语句的完整形式就是：
if<条件判断1>:
<执行1>
elif<条件判断2>:
<执行2>
elif<条件判断3>:
<执行3>
else:
<执行4>
s=input('birth:')
birth:1989
>>> birth=int(s)
>>> if birth<2000:
... print('00前')
... else :
... print('00后')
空格特别重要，语句块对整体规则
if语句执行有个特点，它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略掉剩下的elif和else
简写
if x:
print('True')
只要x是非零数值、非空字符串、非空list等，就判断为True，否则为False。
invalid syntax#语法错误
unexpected indent
1) 缩进应该是四个空格。if请顶格写，if下面的两行，行首四个空格。
2) age输入是字符串类型，需要转成整数才能比较大小
两种循环：
for x in range(i):
range(i)函数：从0到i的所有数
break:
n =1
while n <=100:
if n >10: # 当n = 11时，条件满足，执行break语句
break # break语句会结束当前循环
print(n)
n = n +1
print('END')
体重肥胖问题代码：
bmi = weight/(height**2)
if bmi<18.5:
print("过轻: %.1f" %bmi)
elif 18.5<=bmi<25:
print("正常: %.1f" %bmi)
elif 25<=bmi<28:
print("过重: %.1f" %bmi)
elif 28<=bmi<32:
print("肥胖: %.1f" %bmi)
else :
print("严重肥胖%.1f"%bmi)
coutinue
n =0
while n <10:
n = n +1
if n %2==0: # 如果n是偶数，执行continue语句
continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
print(n)
dict简称字典 相当于 Map，是一个键值对
如果key不存在，dict就会报错：通过in （key in d)
或者get（）判断 (d.get(key))可以返回None，交互界面不显示或者 d.get(key,-1)不存在时反回-1。
pop(key)key和value同时删除
和list比较，dict有以下几个特点：
查找和插入的速度极快，不会随着key的增加而变慢；
需要占用大量的内存，内存浪费多。
而list相反：
查找和插入的时间随着元素的增加而增加；
占用空间小，浪费内存很少。
所以，dict是用空间来换取时间的一种方法。
dict的key必须是不可变对象。
Set：无序且不重复的；
s = set([1,2,3])#里面是一个list集合[1,2,3];但输出为{1,2,3}表示有这几个元素
add(key)添加key
remove(key)删除key
a.sort()#原地排序
>>> a ='abc'
>>> b = a.replace('a','A')
>>> b
'Abc'
>>> a
'abc'
a是变量，而'abc'才是字符串对象！有些时候，我们经常说，对象a的内容是'abc'，但其实是指，a本身是一个变量，它指向的对象的内容才是'abc'：
当我们调用a.replace('a', 'A')时，实际上调用方法replace是作用在字符串对象'abc'上的，而这个方法虽然名字叫replace，但却没有改变字符串'abc'的内容。相反，replace方法创建了一个新字符串'Abc'并返回，如果我们用变量b指向该新字符串，就容易理解了，变量a仍指向原有的字符串'abc'，但变量b却指向新字符串'Abc'了：
│ a ───────────────>│ 'abc' │
│ b │─────────────────>│ 'Abc' │
所以，对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。
调用函数
定义函数 def
def my-hanshu(x):
if x>0 :
return x
else x<0:
return -x
defnop(): #空函数
pass
参数个数不对，并抛出TypeError错误；
参数类型不对，python无法检查
数据类型检查，用isinstance()实现
def my_bat(x):
if not isinstance(x(int,float)):
raise TypeError("bad operand type") #抛出异常
if x>=0:
return x
else :
return -x
调用my_bat('A')
打印Bad operand type
>>> x, y = move(100,100,60, math.pi /6) >>> print(x, y)151.9615242270663270.0
>>> r = move(100,100,60, math.pi /6) >>> print(r)(151.96152422706632,70.0 python 返回多值就是返回一个（r)tuple，将变量按位置赋给相对应的值(x=r[1];y=r[2])；
import math #求方程的解
def my_jie(a,b,c):
m=b*b-4*a*c
if m>=0:
x=(-b+math.sqrt(m))/(2*a)
y=(-b-math.sqrt(m))/(2*a)
return x,y
else :
print("无解")
位置参数 power(x)
默认参数power(x,n=2) #而对于n > 2的其他情况，就必须明确地传入n，比如power(5, 3)。
定义默认参数要牢记一点：默认参数必须指向不变对象！（str、None)
def add_end(L=None):
if L is None:
L = []
L.append('END')
return L
可变参数：可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple
def kebian(*numbers): #在参数前加*，在函数内部，接收到的是一个Tuple
sum=0
for n in numbers:
sum=sum+n*n
return sum
kebian(1,2,3)
#如果已经有一个Tuple或list，可以用’
num=[1,2,3]
kebian(*num)
关键字参数：允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict
def person(name,age,**kw):
print(name,age,kw)
>>>dirc={'city':'beijing','gender':'女'}
person(name,age,**dirc)
#**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
命名关键字参数：
定义：defperson(name, age, *, city, job):
print(name, age, city, job)
默认值：
def person(name,age,*,city='beijing',job):
print(name,age,city,job)
调用及打印：
>>> person('Jack',24, job='Engineer')
Jack 24 Beijing Engineer
参数组合:必选参数、默认参数、可变参数、命名关键字参数和关键字参数。