命令模式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

参数组合:必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

递归