环境变量的配置

• 在下载、解压、准备编译环境、安装依赖包、预编译、编译和安装完成后，前往
  • 需要配置环境变量
• PATH：
  • 目的，让系统帮我自动找到命令执行文件路径
  • path值：一堆目录，每隔目录之间用: 隔开 ```bash vim ~/.bashrc 新增内容

PATH=$PATH:/usr/python-3.6.1/bin

还可以定义一个新变量 PYTHON_HOME， 以后就只需要更改一个地方了

- 生效 `source ~/.bashrc`   
   - /etc/profile  是整个系统的环境变量配置文件，尽量不改，是不好的习惯
- 最后安装一个小工具ipython， 
   - `pip3 install ipython3`   使用python3，就用 /bin 下面的ipython3
- 然后，windows 之后也要安装py
<a name="pYRbS"></a>
# 编写程序
- 和shell 一样，python也是解释性语言，

vim 01anli.py

!/usr/python-3.6.1/bin/python3

print(“hello world”) def main(): print(“end~”)

- 赋予执行权限后，同样可以运行
   - `chmod u+x 01anli.py`    `./01anli.py`

vim ~/.vimrc set nu set ts=4 制表符占4个字符 set sw=4 向左向右异动时占4个字符

   - python2 要运行程序，需要添加一行  `#encoding=UTF-8`   因为python2中不支持中文的字节编码
      - 或者 `# -*- coding: utf-8 -*-`  
- ipython3 好用
---
- 变量三个要素：变量的名字，~~变量的类型~~，变量的值
- 标识符：由字母、下划线和数字组成，且数字不能开头，一些特殊含义的字符不行。
   - 区分大小写
   - 小驼峰命名法，大驼峰命名法，
   - 还有就是用下划线“_” 来连接所有的单词（就不用区分大小写了），一般用这个
- 查看关键字（保留字）
   - `import keyword`   `keyword.kwlist`   
```python
vim 03shuchu.py
a=35
b=2
my_name="xiaobai"
# 如果有表达式用小括号， 如果有多个变量替换也要加小括号，并且每个变量用逗号隔开
# s是字符串（所有的类型）的变量替换, d是整数，f 是浮点数，x 是十六进制整数
print ("wode nianling wei: %dsui~,我的名字是： %s"%(a+b,my_name))
#输出的钱都是四位数，如果不够4位用0填充
print ("我有人民币：%04d钱"%money)
# 精确到小数点后两位
print ("圆周率是： %.2f"%money)
# 每一个%表示一个占位符， %% 第一个表示转义符
print ("我们的胜率是： %d%%"%a)
#python3将输入的内容作为字符串，2中input输入的内容作为表达式（所以可能被传入恶意代码）
age=input("请输入年龄： ")
print (type(age))
age=int(age)+2
print ("你的年龄为： %s"%age)

• if elif else 判断

  age=int(input("请输入年龄： "))
  sex=input("请输入性别： ")
  #and 并且, or 或者, not 不满足后面的条件
  if age >= 18 and sex == "男" :
    print ("可以做苦力")
  elif age < 18 or sex == "女" :
    print ("不用做苦力")
  #sex !='女' and sex != '男'
  elif not (sex == '女' or sex == '男' ) :
    print ("非男非女")
  else :
    pass#以后要填充代码，为保证不出现语法错误

• 特殊的真和假 ```python age=int(input(“请输入值： “)) if age : print (“age 非 0”) else : print (“age = 0”)

name=”” if name: print (“name 不是一个空字符串”)

- 练习，
```python
shengao=float(input("身高： "))
tizhong=float(input("体重： "))
print ("小明的身高为：%.2f，体重为：%.2f"%(shengao,tizhong))
# / 表示浮点数除法，返回float结果；// 表示整数除法，返回一个不大于/ 计算结果的最大整数int
bm=tizhong/(shengao**2)
print ("BMI指数为： %s"%bm)
#print ("BMI指数为： %.2f"%bm)
#sbm=("%.2f"%bm)
#print ("sbm zhishu wei: %s"%sbm)
if bm < 18.5 :
    rprint ("过轻")
elif bm >= 18.5 and bm < 25 :
    print ("正常")
elif bm >= 25 and bm < 28 :
    print ("过重")
elif bm >= 28 and bm < 32 :
    print ("肥胖")
else :
    print ("严重肥胖")

循环

# 打印一个矩形
y=1
while y<=10 :
    x=1
    while x<=10 :
        #print函数默认在输出后就换行，在ipython3里面 help(print)
        print ("*",end="")
        x+=1
    print ("\n") #print ("") 输出一个空的字符串也是换行
    y+=1
print ("已经完成~")

• 循环多少次（while中循环次数由条件决定）
• 在循环过程中做什么
• 变量怎么变化？

  #打印九九乘法表
  14 hang=1
  15 while hang<=9 :
  16     lie=1
  17     while lie<=hang :
  18         print ("%d*%d=%d\t"%(lie,hang,lie*hang),end="")
  19         lie+=1
  20     #换行
  21     print ("")
  22     hang+=1
  23 print ("结束了~")

• break 和 continue

  age=int(input("请输入年龄： "))
  i=1
  #相当于不知道循环多少次，一直到满足break的条件后循环就会终止
  while True :
    if i==age :
        print ("你的年龄为： %d"%i)
        break
    else :
        print ("caicuole! ")
    i+=1

i=0
while i<10 :
    i+=1;
    if i%2==0 :
        print ("%d 是偶数"%i)
        continue
    #continue，不管循环语句内的后面有多少代码，都不执行，直接跳过进入下次循环
    print ("当前的i 是 %d"%i)
else :
    print ("else 表示不满足条件时调用的代码，这时i为%d"%i)

#打印等边三角形，
i=int(input("请输入等边三角形的行数： "))
a=0
while a<i :
    b=0
#打印当前行前面的空格，第一行不打印空格，
    while b<a :
        print (end=" ")
        b+=1
    c=i-a
#打印*号，第一行打印i个*
    while c>0 :
        print ("*",end=" ")
        c-=1
    print ("")
    a+=1

for循环

字符串常用方法

• name[-1] 取字符串最后一个字符，name[0]取字符串第一个字符，name[len(name)-1] 取最后一个字符
• 前片是对操作的对象截取其中一部分的操作，字符串、列表、元组都支持切片操作
  • 包头不包尾，（和range、列表， 一样的）
  • name[0::2] 截取从第一个字符开始到最后，隔一个截取一个，所以步长是2
  • name[-1::-1] 将字符串反转，起始位省略掉就截取到字符开始位了
• 查找字符串
  • my_str.find (“xiaobai”) 所查找字符串的第一个字符所在的下标位，my_rfind 从右向左查找
    • 找不到返回 -1
  • my_str.index， 找不到会报错，都是从左边查找，从右向左my_str.rindex
• 分割字符串
  • my_str.split(“ “,2)， 将字符串按照空格拆分开， 分成3个片段，结果中没有隔开符（空格）
    • my_str.split(“\n”) 根据换行符分割，不需要再记另一个函数了
    • name.split() 什么都不接，就是默认把常用的隔开符都隔开了
  • my_str.partition(“ “)， 按照空格拆分开，并且空格也算做一个片段
• 大小写
  • my_str.title() 将每个单词的首字母大写
  • my_str.capitalize() 将字符串的第一个字符大写
• 字符串对齐
  • my_str.ljust(width) 左对齐，并用空格填充至长度width 的新字符串
  • my_str.rjust(width)
  • my_str.center(width)
• 删除空白字符
  • my_str.lstrip 删除左边的空格
  • my_str.rstrip 删除右边
  • my_str.strip 删除左右两边的空格
• “”.join(names) 将names（列表等）连接成一个字符串， “-“.join(names)

• 查找方法说明， help(my_str.strip)
  

  列表

• list 是一种有序的集合，可随时添加和删除其中的元素， [任何类型的数据]

• lis.append(900) 在列表最后一位添加元素
  • lis.extend(names) 将names 列表的元素添加进lis 中
  • lis.insert(0,”000”) 在0号下标位插入”000” 元素
• del names[1] 删除列表中第二个元素
  • names.pop() 只是删除列表的最后一个元素，并返回
  • names.remove(200) 删除列表中200 元素

• names.reverse() 将列表逆置， names[-1::-1]

  • names.sort() 一定保证列表中元素是同一类型，否则报错 names.sort(reverse=True) 按照降序排序

    元组

• 不支持修改、增加元组中的元素。只要声明好后，长度就固定了， (任何类型的数据)

  • 所以只有查，没有增删改

• 但是元素中存在列表，就可以修改了

  • my_tuple[2][0] 元组中第3个元素是列表，进而修改列表中的第1个元素

    字典

• 使用键和value 来存放多个值；字典中包括多个元素，每个元素都有键和value

• d={“xiaobai”:75,”xiaohei”:80,”tom”:90}
  • d[‘xiaobai’]
• 键是不允许重复的，出现重复后会覆盖；值可以重复
• 没有顺序，所以不能用下标访问
• 在不确定字典中是否存在某个键又想获取其值时，可以使用get方法，（就不会报错了）还可以设置默认值
  • addr=stus.get(‘address’)， addr=stus.get(‘address’,’beijing’)
• 新增，stus[‘address’]=’beijing’
  • 查询，stus[‘name’]
  • 删除，del stus[‘sex’]， del stus删除整个字典，(clear删除字典后不会回收)

集合迭代的补充，，
names=["zs","ls","ww","sl"]
names2=("zss","lss","www","sll")
#第一种迭代
j=0
print ("序号\t姓名")
for i in names:
    j+=1
    print ("%d\t%s"%(j,i))
print ("="*30)
#第二种,enumerate 枚举，内置函数
#从1开始计数
for i,item in enumerate(names,1):
    print ("%d\t%s"%(i,item))

字典的常用函数

• len()测量字典中，键值对的个数
• keys() 返回一个包含字典所有元素的键的列表
  • values() 返回包含所有value 的列表

• items() 返回一个包含所有（键、值）元组的列表

  #迭代字典常用方式
  for item in stu.items(): 
    print ("key: %s,value: %s"%item) #item就是元组

• has_key() 如果key在字典中，返回True，否则返回false

  • 一般用in 就行， key=”name” if key in stu: print (“%s在字典中”%key)
  • if stu.has_key(key): 其实就是条件判断表达式， python3 没有

    可变类型和不可变类型

• 可变类型：列表，字典

  • 不可变类型：数值类型，字符串，元组，
• 在可变类型中，a+=b <> a=a+b
  • a=[1,2] b=a b+=[3,4] 此时，原来的列表会变成[1,2,3,4]
    • 因为a和b都指向一个内存地址
  • b=b+[3,4] 先执行= 右边的表达式，完后赋值给b，b就指向一个新的列表了，所以a 还是之前的列表
  • id(a) 可以查看到引用
• 可变类型：值可以修改（内存地址不变，但是所保存的值变化了），引用可以修改（变量的内存地址变化了）
  • = 赋值符号，作用就是将引用改了
  • 不可变类型：

函数

• 提高代码利用率
• 不带参数的： def 函数名(): pass
• 带参数的： def 函数名(形参1，形参2.。。) #形参1：名字随便取，不需要之前声明，也不会和之前定义的参数冲突（局部变量） ```python def test2(a,b): sum=a+b return sum

  return 被执行之后，不管return后面还有什么代码，都不会执行

  a=1 b=1 sum=test2(a,b) print (“%s和%s的和为：%s”%(a,b,sum))

def test2_noretu(a,b): sum=a+b s=test2_noretu(a,b) print (s)

def test1(r): s=3.14(r*2) print (“面积为：%s”%s)

r=11.8 test1(r)

```python
def sum_plus(a,b):
    if not isinstance(a,(int,float)):
        print ("传入的a是%s，不是一个数字类型，方法结束"%a)
        return#如果a不是一个数字，函数后面的代码没有必要执行
    elif not isinstance(b,(int,float)):
        print ("传入的b是%s，不是一个数字类型，方法结束"%b)
        return # 什么都不接，表示返回值为none
    sum=a+b
    return sum
s=sum_plus(21,2)
print (s)

def avg_3num(a,b,c):
    if is_num(a) and is_num(b) and is_num(c): #执行代码从上往下执行，但是函数里面的代码是不执行的
        #，不执行def下面的，只是内存中加载了这个函数。在后面 = 赋值时调用函数时才开始执行函数里面的代码
        return (a+b+c)/3
    else:
        print ("没法计算平均值")
def is_num(a):
    if not isinstance(a,(int,float)):
        print ("传入的实参是%s，不是一个数字类型，方法结束"%a)
        return False
    else:
        return True
avg=avg_3num("abc",2,3)
print (avg_3num)

• test1 函数的局部变量，结尾加个 return a ，然后在test2 函数中， b=test1() 就可以取到test1 中的局部变量a 的值
  • 如果函数中的局部变量和全局变量的名字一样，优先使用局部变量
  • 在函数内使用 a=20 ， 是定义了一个局部变量，要想更改全局变量，在代码上一行加 global a
• 在函数中修改全局变量：
  • 如果是可变类型可以执行修改变量的值，
  • 想要在函数中修改不可变类型的全局变量，本质上是修改不可变类型的引用，（加上global）

• 全局变量的定义放在调用函数之前就OK

  参数

• 缺省参数，带有默认值的参数一定要位于参数列表的最后面

• 不定长参数， sum 以元组存储后面的参数 ```python def test1(x,y,*args): print (x,y) print (args) sum=x+y for i in args:

    sum+=i

  print (“和为：%s”%sum)

def test2(x,args,*kwargs): #keyword指带有名字的参数 print (x) print (args) print (kwargs) sum=x for i in args: sum+=i for i in kwargs.values(): sum+=i print (“和为：%s”%sum)

test1(2,3,4,5,6,7)

test2(2,3,4,num1=5,num2=6)

集合的拆包

nums=[3,4] nums2={“num1”:5,”sdfs”:6} test2(2,nums,*nums2)

<a name="VBRnr"></a>
### 学生管理系统
```python
def print_menu():
    print ("="*30)
    print ("学生管理系统".center(20))
    print ("输入1：添加学生")
    print ("输入2：查找学生")
    print ("输入3：修改学生")
    print ("输入4：删除学生")
    print ("输入5：查看所有学生")
    print ("输入6：退出")
def add_student():
    name=input ("请输入学生的姓名：")
    age=int(input("请输入学生的年龄："))
    qq=input ("请输入学生的QQ号：")
#一个学生包括三个信息，这三个信息存在一个字典中
    stu={}#声明一个字典变量
    stu["name"]=name #向字典中添加一个key
    stu["age"]=age #向字典中添加一个key
    stu["qq"]=qq #向字典中添加一个key
    stus.append(stu)
    print ("添加成功")
def search_student(name):
    for item in stus:
        if item["name"]==name.strip():
            print ("%s 学生存在"%name)
            print_student(item)
            #break
            return item #同样可以终止循环
    else:
#break是整个循环终止，不会执行else
        print ("学生%s没有找到"%name)
def del_student(name):
    student=search_student(name)
    stus.remove(student)
def print_student(item): 
    print ("%s\t%s\t%s"%(item["name"],item["age"],item["qq"]))
def print_all_student():
    print ("序号\t姓名\t年龄\tQQ号")
    for i,item in enumerate(stus,1):
        print ("%s\t"%i,end="")
        print_student(item)
#一个学生包含很多信息，一个学生一个字典，学生列表用列表存储 
def main(): 
    print_menu()
    while True:
        operate=input ("请输入你想要的操作：")
        if operate=="1": 
            add_student()
        if operate=="2":
            name=input ("请输入要查找学生的姓名：")
            search_student(name)
        if operate=="3":
            pass
        if operate=="4":
            name=input ("请输入要删除学生的姓名：")
            del_student(name)
        if operate=="5":
            print_all_student()
        if operate=="6":
            break
stus=[]#全局变量
main()

递归函数

• 如果一个函数在内部调用自身，这个函数就是递归函数
  • 本质上是一个方法的循环调用，注意有可能出现死循环
  • 一定要定义递归的边界（什么时候退出循环）

• 比方说阶乘

  def test1(n):
    if n==1:
        return 1
    return n * test1(n-1)
  print (test1(4))

• 斐波拉切数列

  def test(n):
    if n==1 or n==2:
        return 1
    else:
        return test(n-1)+test(n-2)
  #n=int(input("请输入需要求的数字："))
  #print(test(n))
  n=[]
  for i in range(1,20):
    n.append(test(i))
  print (n)

• 但是，这样来看F(n) 要计算很多复杂的值，时间复杂度为O(2^n)，2的n次方。下面的非递归的时间复杂度是O(n) ```python

  !/usr/bin/env python

  -- coding:utf-8 --

def fibonacci(n): if n == 0: return 0 elif n <= 2: return 1 else: num1 = 1 num2 = 1 for i in range(2,n-1): num1,num2 = num2,num2 + num1 return num1 + num2 print(fibonacci(100)) ```