python语法基础-if for while循环-range-函数基础

程序结构
三种结构
顺序
循环
分支

分支结构¶
分支结构基本语法
if （如果） 条件表达式：
语句1
语句2
语句3
…
条件表达式就是计算机结果必须为 布尔值 的表达式
表达式后面的:冒号不能少（英文输入法）
注意if后面出现的语句，如果属于if语句块，则必须同一个缩进等级（4空格/1TAB键）
条件表达式结果为 True 执行if后面的缩进语句块

# if 语句例子1
# 如果我和una一辈子不分开，我就太幸福了。
love1 = "我和una一辈子不分开"
if love1:
    print ("我就太幸福了")
    print ("我要让她幸福一辈子")
print ("我们都要幸福啊!")

# 字符串的真假：
#只有空字符串（长度为0的练空格都没有的）为False，其余为True
love2 = ""
if love2:
    print ("我就太幸福了")
    print ("我要让她幸福一辈子")
print ("我们都要幸福啊!")


love3 = "  "
if love3:
    print ("我就太幸福了")
    print ("我要让她幸福一辈子")
print ("我们都要幸福啊!")

双向分支
if…else… 如果…就…
语法结构：
if： 条件表达式
语句1
语句2
else：
语句1
语句2

# if 语句例子2
age = 19
if age > 18:
    print ("可以去网吧")
else:
    print ("禁止上网")

# input 的作用
#1、在屏幕上输出括号内的字符串
#2、 接受用户输入的内容并返回到程序进行判断
#3、input返回的内容一定是字符串类型
# input负责接受用户的输入并把内容返回给变量
gender = input("请输入你的性别")
# 打印输入的内容
print (gender)
if gender == "man":
    print ("走抽烟喝酒打游戏去")
else:
    print ("你是男是女啊")

#考试成绩判断
#成绩由用户输入
#90以上：输出优秀
#80-90；良
#70-80：中
#60-70：平
#60以下：输出：学渣
#输入成绩需要用到input函数

#input 输入的值全是字符串类型
score = input ("请输入你的成绩必须是数字")
#解决输入是字符串的问题
score = int (score)
if score >= 90:
    print ("优秀")
if score >= 80 and score < 90:
    print ("良")
if score >= 70 and score < 80:
    print ("平")
if score < 60:
    print ("学渣")

多路分支
就是很多分支/判断的情况，就叫多路分支
elif语句允许检查多个表达式是否为TRUE，并在其中一个条件求值为TRUE时立即执行对应代码块。
与else语句类似，elif语句是可选的。 但是，与else语句不同的是，else语句最多可以有一个语句，在if之后可以有任意数量的elif语句。

• if…elif…else
  • 语法结构：
• if： 条件表达式
  • 语句1
  • 语句2
• elif：
  • 语句1
  • 语句2
• else:
  • 语句1
  • 语句2
    elif可以有好多个，根据实际情况
    else 可选
    多路分支最多只会执行一种情况

#考试成绩判断
#成绩由用户输入
#90以上：输出优秀
#80-90；良
#70-80：中
#60-70：平
#60以下：输出：学渣
#输入成绩需要用到input函数

#input 输入的值全是字符串类型
score = input ("请输入你的成绩必须是数字")
#解决输入是字符串的问题
score = int (score)
if score >= 90:
    print ("优秀")
elif score >= 80:
    print ("良")
elif score >= 70:
    print ("平")
elif score >= 60:
    print ("差")
else:
    print("学渣")

if 语句补充
if 语句可以嵌套使用，但是不推荐 如;
if score >= 90:
print (“优秀”)
if score >= 80 and score < 90:
print (“良”)
if score >= 70 and score < 80:
print (“平”)
if score < 60:
print (“学渣”)
python里面没有switch语句
循环语句
重复执行某个固定的动作或者任务叫做循环
分类
for
while
for 循环
语法
for 变量 in 序列：
语句1
语句2 …

# for循环案例
#比如 [1,2,3,4,5,6,7]
list_one = [1,2,3,4,5,6,7]
for shuzi in list_one:
    print (shuzi)
    print (shuzi+10)
    print (shuzi+100)

#案例2
#如果是una，那就是我的最爱
#如果不是，就是普通人
xingming_list = ["abc","efg","una"]
for love in xingming_list:
    if love == "una":
        print("我的最爱")
    else:
        print ("普通人")

for-else语句
for循环结束的时候，有时候需要执行一些收尾工作，此时需要使用else语句进行收尾
else语句是可选的

#案例
#如果是una，那就是我的最爱
#如果不是，就是普通人
#如果没有una，就不再爱了
xingming_list = ["abc","efg","hij"]
for love in xingming_list:
    if love == "una":
        print("我的最爱")
    else:
        print ("普通人")
else:
    print ("不再爱了")

break，continue，pass
break： 无条件结束整个循环，简称循环猝死
continue: 继续
pass: 占位符 代表这句话啥也不干，但是不是跳过

# 确定一个数字队列中是否包含数字7
# 确定是否包含，只要找到1个7即可确定，不需要继续往下查找，使用 break进行收尾
dig_list = [1,2,7,3,4,7,5,6,7]
for dig in dig_list:
    if dig == 7:
        print ("找到了一个7")
        break
    else:
        print (dig)

# continue 语句练习
# 在数字1-10中，寻找所有偶数，找到偶数后打印偶数
dig_list = [1,2,3,4,5,6,7,8,9,10]
'''
# continue案例1
'''
for dig in dig_list:
    if dig % 2 == 0:
        print (dig)
        print ("偶数")
    else:
        continue
        
'''
# continue案例2
'''
for dig in dig_list:
    if dig % 2 == 1:
        print (dig)
        print ("奇数")
    else:
        continue
# 以下代码和上面代码等价（一样）       
for dig in dig_list:
    if dig % 2 == 1:
        continue
        print (dig)
        print ("奇数")

#pass案例1
age = 18
if age > 18:
    pass
else:
    print("未成年")

#pass案例2
shuzi = [1,2,3,4,5]
for aa in shuzi:
    pass
    print(aa)

函数学习
range函数
生成有序的序列
生成数字队列可以定制

# range函数案例1
# 生成一个从1到10的数字序列
# range的生成序列的两个面数字是左包括，右不包括(如下所示只包括1不包括10)
dig_list = range (1,10)
for dig in dig_list:
    print (dig)

#range案例2
#打印1到9的数字序列
for dig in range (1,10):
    print (dig)

while循环
一个循环语句
表示当条件成立的时候就循环，适应于不知道具体循环次数，但能确定在某个条件成立的情况下就循环
while 语法
while 条件表达式：
语句1
另外一种表达方法
while 条件表达式：
语句1
else：
语句2

# 案例1
# 如果说年利率是6.7%，本利是每年翻滚，则多少年后本钱会翻倍
benjin = 10000
year = 0 #存放需要翻本的年数
while benjin <20000:
    benjin = benjin * (1 + 0.067)
    year += 1 #(缩写year=year+1)
print (year)
# 案例2
#该案例中循环没有被循环，改如何修改？
while benjin <20000:
    benjin = benjin * (1 + 0.067)
    year += 1 #(缩写year=year+1)
else:
    print (year)

函数
函数是代码的一种组织形式
函数能完成一项特地的工作，一般 一个函数值完成一项工作
有些语言中，分两个概念 ：函数和过程 ，有返回结果的叫函数，无返回结果的叫做过程，在python中不加以区分
函数的使用：
函数需要提前定义
使用函数，俗称 调用
定义一个函数
只是定义函数的话是不会被执行的，只有调用时才执行
1，def关键字，后跟一个空格
2，函数名字，自己定义，起名需要遵循便令命名规则，约定俗称，大驼峰命名只给类用
3，后面括号和冒号不能省略，括号内可以由参数
4，函数内所有代码缩进
参数
str
list,tupe,set,map

#定义函数案例
#def 空格 括号
def hanshu1():
    print ("在同一个缩进内的才是函数内容")
    print("我是一个函数")
print ("因为不在一个缩进内所以不是函数")

#函数的调用
#直接写出函数的名字，后面的小括号不能省略，括号内的内容根据情况(定义函数时是否输入东西就是参数)
hanshu1()

函数的参数和返回值
参数：负责给函数传递一些必要的数据或者信息
形参（形式参数）：在函数定义的时候用到的参数，没有具体值，只是一个占位符好
实参（实际参数）：在调用函数的时候输入的值
返回值; 调用函数的时候的一个执行结果
使用 return 返回结果
如果没有值需要返回，推荐使用 return None 表示函数结束
函数一旦执行return，则函数立即结束
如果函数没有return 关键字，则返回默认的None

# 形参和实参
#参数una只是一个符号
#调用得时候用另一个
def hanshu2 (una):
    print ("{},你在干嘛啊？".format(una))
    print ("{},我很想你。".format(una))
    
u = "杨雨"
#调用函数，需要把u作为实参传入

hanshu2(u)

a = "雨雨"
hanshu2(a)

#返回
def hello (una):
    print ("{0},你在干嘛啊？".format(una))
    print ("{},我很想你。".format(una))
    return None
    
u = "杨雨"
#调用函数，需要把u作为实参传入
hello(u)

# 九九乘法表
# version 01
for o in range (1,10):#控制外循环，从1到9
    for i in range (1,o + 1):#内循环，每次从第一个数字开始，打印到跟行数相同的数量
        print (o * i,end="  ") #行是o 列是i
    print ()

#使用函数打印九九乘法表
def jiujiu():
    for o in range (1,10):#控制外循环，从1到9
        for i in range (1,o + 1):#内循环，每次从第一个数字开始，打印到跟行数相同的数量
            print (o * i,end="  ") #行是o 列是i
        print ()
    return None
jiujiu()
jiujiu()

#函数嵌套使用
def printline(line_num):
    '''
    line_num:代表行号
    '''
    for i in range(1, line_num + 1):
        print (line_num * i,end = "  ")
    print ()

def jiujiu():
    for o in range (1,10):
        printline(o)
    return None
jiujiu()

参数详解
参数分类
普通参数/位置参数
默认参数
关键字参数
收集参数

# 普通参数案例
def a(A,B,C,D):
    print (A + C)
    return None
a(1,2,3,4)
#----------------------------------

def a(A,B,C,D):
    print (A + C)
    return None
a2(1,2,3,)#普通参数也叫位置参数因下面参数和上面未对应上所以报错

# 默认参数案例
def default_para(A,B,C=100):
    print (A + B)
    print (C)#c就是默认参数
    return None
default_para(100,200)

# 关键字参数案例
def keys_para(A,B,C):
    print (A + B)
    print (C)
    return None
keys_para(A=1,B=2,C=10)
keys_para(C=10,B=2,A=1)#调用参数没有顺序的影响

STR字符串
str
转义字符
格式化
内建函数
字符串
表示文字信息
用单引号，双引号，三引号括起来

s = "i love una"
print (s)

转义字符
用一个特色的方法表示出一系列不方便写出的内容，比如回车键，换行符，退格键等
借助反斜杠字符，一旦字符串中出现反斜杠，则反斜杠后面一个或者几个字符表示已经不是原来的意思了，进行了转义
在字符串中，一旦出现反斜杠就要加倍小心，可能有转义字符出现
不同系统对 换行操作有不同的表示
windows： \n
linux： \r\n

#转义字符案例1
#想表达    Let's Go
#使用转义字符
a = 'Let\'s Go'
print (a)

# 使用单双引号嵌套
b = "Let's Go"
print (b)

#表示斜杠\
#比如 表示： C:\etc\mnt
c = "C:\\etc\\mnt"
print (c)



#回车换行
#效果如下：
# I
# love
# una
d = "\n I \n love \n una"
print (d)
#windows下 \r\n效果一样
d = "I \r\nlove\r\nuna"
print (d)

转义字符:\ (反斜杠-可以打印出一个反斜杠)

转义字符:’ （单引号-可以打印出一个单引号）

转义字符:" (双引号-可以打印出一个双引号)

转义字符:\a (响铃-用于触发系统蜂鸣器)

转义字符:\n (换行符-将光标移动到下一行的开头)

转义字符:\t (水平制表符-将光标向右移动一个制表符位)

格式化
把字符串按照一定格式打印出来或者填充
格式化分类
传统格式化
format

# 填充
a = "i love una"
print (a)
a = "i love yangyu"
print (a)
a = "i love yuyu"
print (a)

字符串的传统格式化方法
使用%进行格式化
%（百分号）也叫占位符
%s:字符串
%r ：字符串，但是是使用repr而不是str
%c : 整数转换为单个字符
%d : 十进制整数
%u ： 无符号整数
%o ： 表示八进制
%x ： 十六进制，字母为小写（x为小写）
%X ： 十六进制，字母为小写（X为小写)
%e ： 浮点数（e为小写），例如2.87e+12
%E ： 浮点数（E为小写），例如2.87E+12
%f,%F : 浮点数十进制形式
%g，%G ： 十进制形式浮点数或者指数浮点数自动转换
格式符前边出现"-“表示左对齐
格式符前边出现”+"表示右对齐
0位数不足用”0“补齐
width表示宽度
pricision 精度

# %s 表示简单得字符串
# 占位符可以单独使用
s = "i love %s"
print (s)

s = "i love %s"
print (s%"una")#想用某个东西替换占位符
print (s%"杨雨")

print("i love %s"%"杨雨")
#占位符一般只能被同类型替换，或者替换类型能被转换成占位符的类型
print("i love %s"%520)

a = "gemoumou同学现在%d斤了，感觉瘦了不少"
print (a%120)
#以下打印会出错
print (a%"120")

b = "i am %fKG weight,%fM height"
print (b)
#如果需要格式化的信息多个，则用括号括起来
print (b%(60,175))


#实际需要进行格式化的信息数量必须与百分号后面的出的数据量匹配，否则报错
# 如下面例子，实际需要格式化的为4个地方，但是给出的数据为三个，则报错
b = "i am %.2fKG weight,%.2fM height"   #%.2的意思就是小数点后面几位的意思
print (b%(60,175))

format格式化¶
使用函数形式进行格式化，代替以前的百分号

#不用指定位置，按顺序读取
#方式1
s = "{} {}!"
print (s.format("hello","una"))
#方式2
s = "{} {}!".format("hello","una")
print (s)
#设置指定位置
s = "{0} {1}".format("hello","una")
print (s)

s = "{1} {1}".format("hello","una")
print (s)

s = "i love {1} and {0} i love me".format("杨雨","una")
print (s)


#使用命名参数
s = "我是{name1}，我最喜欢{name2}"
s = s.format(name1 = "gpc",name2 = "una")
print (s)

#通过字典设置参数，需要解包
s = "我是{a1}，我最喜欢{a2},我们要{a3}"
s_zidian = {"a1":"gpc",\
            "a2":"una",\
            "a3":"幸福一辈子"}
s = s.format(**s_zidian)
print (s)

#对数字的格式化需要用到
s = "gpc is {:.2f}m heigh,{:.2f}kg weight"
print (s.format(1.73, 60.00))
#使用大括号{}来转移大括号
s = "format 函数是使用{}来进行占位"
print (s)

str 内置函数
很多语言字符串使用 string表示，但是python中用str表示字符串
字符串查找类， find index，islower
find ：查找字符串中是否包含一个子串
index : 跟find的唯一区别是index如果找不到会异常报错
rfind ，lfind ： 从左开始查找或者从右开始查找

a = "ge peng cheng love yang yu"
# 返回第一次发现这个字符串的位置
s1 = "yang yu"
s.find (s1)
#返回-1表示没找到
s2 = "una"
s.find (s2)

s.index (s1)

#index 会报错或者引发异常
s.index (s2)

#使用的时候可以使用区间
a = "ge peng cheng love yang yu and yu yu"
s1 = "yu"
#从下表20开始查找，看能否找到
a.find (s1,24)

判断类函数
此类函数的特点一般使用is开头，比如 islower

isalpha：判断是否是字母，需要注意两点：

此函数默认的前提是字符串至少包含一个字符，如果没有，同样返回false
汉字被认为是 alpha，所以此函数不能作为区分英语字母还是汉字表示，区分中英文请使用unicode码
注意使用区别，防止被坑
isdigit,isnumeric,isdecimal 三个判断数字的函数

此类函数不建议使用，在后期爬虫中，判断是否是数字采用正则表达式的方式

# 以下三个都不是，因为有除了字母以外的空格等
s1 = "我对着天空发誓，葛鹏程深深爱着杨雨"
s2 = "bengboerba is friend of baboerbeng"
s3 = "www.gpc.com is the 1.txt"
print (s1.isalpha())
print (s2.isalpha())
print (s3.isalpha())

aa = "一二三四"
print (aa.isdigit())
print (aa.isnumeric())
print (aa.isdecimal())

内容判断类
startswith/endswith ： 是否以xxx开头或者结尾
检测某个字符串是否以某个子串开头，常用三个参数
suffix：被检查的字符串，必须有
start ： 检查范围的开始
end ： 检查范围的结尾
isupper/slower：判断字符串是否是大写或者小写

gpc = "ge peng cheng"
yy = "yang yu"
l = "ge peng cheng love yang yu"

print (gpc.startswith(gpc))
print (yy.endswith(yy))

#判断下列字符中是否全是小写
# s1 s2 包含空格，但空格不影响结果
s1 = "ge peng cheng love yang yu"
s2 = "Ge Peng Cheng love Yang Yu"
s3 = "gepengchengloveyangyu"
s4 = "葛鹏程爱杨雨"
print (s1.islower())
print (s2.islower())
print (s3.islower())
#汉字字符串中无大小写区分
print (s4.islower())
print (s4.isupper())

操作类函数
format ： 格式化用的
strip ： 用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。
lstrip rstrip
join ： 对字符串进行拼接（是吧可迭代的字符串拼接在一起，中间使用调用字符串作为分隔符）

l = "         ge peng cheng love yang yu            "
# strip 删除末尾空格或者换行符
print (l.strip())
print (l)

#join案例
s1 = "!!!!!"
s2 = "________"
s3 = "         "
ss= ["ge pengcheng","yangyu","una","gpc"]
print (s1.join(ss))
print (s2.join(ss))
print (s3.join(ss))

python中的内置类型
str
list
tuple
set
dict
list 列表
一组由有序数据组成的序列
数据有先后数据
数据可以不是一类数据
list 的创建
直接创建，用中括号创建，内容使用因为逗号 , 隔开
使用list创建
列表包含单个字符串的时候是一个特例

#直接赋值创建列表
l1 = [1,2,3,4,5]
#list内的数据可以不是一个类型
l2 = [1,2,3,"gepengcheng","杨雨"]
print (l1)
print (l2)

#创建列表的第二种方式
l3 = list ()
print (l3)
#现实创建l3是什么类型函数
print (type (l3))

内置函数
help ;帮助函数
type ： 现实变量的类型
id ：现实变量id
print ： 打印

# list 创建的特例
s = "gepengcheng"
#想创建一个只含s只包含一个字符串的列表
l1 = list(s)
print (type (l1))
print (l1)

列表的常见操作
访问
使用下标操作，也叫索引
列表的元素索引从0开始
切片操作
对列表进行任意一段的截取需要注意取值范围，左包括右不包括
截取之后创建一个新得列表

l1 = [12,13,11,22,345,33]
#使用下标访问
print(l1[0])
print (l1[3])
#IndexError访问超标
print (l1[15])

#切片操作需要注意取值范围，元素索引从0开始左包括右不包括
l1 = [100,200,300,400,500,600,700,800,900]
print (l1[3:6])
#切片操作下标可以为空
print (l1[:6])
print (l1[3:])
print (l1[:])


print("__________________________________")#分隔符
#下面结果说明切片后生成一个全新的列表
#通过内置函数id可以判断出切片是否生成了一个全新的列表
#id 的作用是用来判断两个变量是否是一个变量
l2 = l1[0:10]
print (id(l1))
print (id(l2))

#切片可以控制增长的幅度，默认增长幅度为1
l1 = [100,200,300,400,500,600,700,800,900,1000]
print (l1[::1])#等于print (l1[:])
print (l1[::2])

print("__________________________________")#分隔符

#下标可以超出范围，超出后不在考虑多余的下标内容
print (l1[:100])
print (l1[100:])

#下标从左往右数从0开始如 0，1，2，3，....
#下标从右往左数从-1开始如 -1，-2，-3，-4....
l1 = [100,200,300,400,500,600,700,800,900,1000]
#下面例子为空，因为默认是从左向右移动
print (l1[-2:-5])
#如果我想从右往左开始 打印900，800，700则：
print (l1[-2:-5:-1])

#如果我想从右往左开始 打印700,800,900则;
print (l1[-4:-1:1])

tuple (元组)¶
可以理解成一个不允许更改的列表

#tuple 创建
# 1,直接用小括号创建
a = ()
print (type(a))
#用小括号创建一个元素的tuple的时候
b = (100)
print (type(b))
c = (100,)
print (type(c))
d = (1,2,3,4)
print (d)
print (type(d))

print ("___________________________________________")#分隔符
# 2,直接用逗号
a1 = 100,
print (type(a1))
b1 = (1,2,3,4)
print (type(b1))

print ("___________________________________________")#分隔符
a2 = tuple ()
print (a2)
b1 = [1,2,3,"gepengcheng"]#要求tuple参数必须可迭代
c1 = tuple (b1)
print (c1)

tuple 其余特征和list基本一致
有序
可以访问不可以更改
元素可以是任意类型

# tuple索引操作
a3 = ["i","love","una"]
print (a3)
b3 = tuple (a3)
print (b3[2])

# tuple 分片操作
print (b3[:])
print (b3[:2])
print (b3[-1::-1])

# 元组的相加
ta = 100,200,300
tb = ("i","love","una")
tc = ta + tb
print (tc)

#tuple 乘法
aa = a3 * 2
print (aa)

# tuple 成员检测
print (a3)
if "una" in a3:
    print ("检测到una")
if "yangyu" not in a3:
    print ("未检测到yangyu")
if "una" not in a3:
    print ("未检测到una")

# 元组遍历(把一段字符拆开)
love = ["i","love","una"]
for i in love:
    print (i)

# 元组嵌套
a4 = ((100,200,300),("i","love","una"),(520,13,14))
#双层循环
for A in a4:
    print (A)
    for B in A:
        print (B)

#使用单层循环
b4 = ((100,200,300),("i","love","una"),(520,13,14))
for i,l,u in b4:
    print (i,l,u)
    
print ("____________________________________")#分隔符
# 上面访问中有一个规定，既i,l,u要跟元组个数进行对应
for i,l,u,y in b4:
    print (i,l,u,y)

#常用元组函数
# len ： 长度
c4 = ((100,200,300),("i","love","una"),(520,13,14))
print(len(c4))

print ("____________________________________")#分隔符

# max/min : 最大值/最小值
d4 = (12,342,31312,212)
print (max(d4))
print (min(d4))

print ("____________________________________")#分隔符

# count ： 对某一元素进行计数
f4 = (1,2,3,4,5,1,1,1,1,1)
print (f4.count(1))

print ("____________________________________")#分隔符

# index : 某一元素所在位置
e4 = (1,2,3,4,5,1,1,1,1,1)
print(e4.index(5))

# tuple的特殊用法
a = 520
b = "yang yu"
print (a,b)

print ("____________________________________")#分隔符

#要求对a，b值进行互换
a,b = b,a
print (a,b)

集合¶
跟数学中集合得概念一致
内容无序+内容不重复

# 集合的定义
# 1，通过set关键字
aa = set ()
print (aa)

#集合定义最多只能定义1个参数
bb = set (1,2,3,4,5,6)
print (bb)

b = [1,2,3,4,5,6,7]
bbb = set (b)
print (bbb)

# 2 ，使用大括号定义
sc = {1,2,3,4,5,6,7,8,11,22,33}
print (sc)

# in 操作
if 2 in sc:
    print ("2在sc里面")
if 9 in sc:
    print ("9在sc里面")
print ("____________________________________")#分隔符
#集合里面的顺序是无序的
for i in sc:
    print (i)

# 集合的另一种遍历
sb = {(1,2,3),(4,5,6),("i","love","una")}
for a,b,c in sb:
    print (a,b,c)

# 集合的生成式
sa = {1,2,3,4,5,6,7,8,9}
# 利用sa 生成一个sb
sb = {a for a in sa}
print (sb)
print ("____________________________________")#分隔符
sc = {a for a in sa if a %2 == 0}
print (sc)
print ("____________________________________")#分隔符
sd = {a for a in sa if a %2 == 1}
print (sd)

print ("____________________________________")#分隔符

#双重for循环
#把 sa 中的每一个元素的平方生成一个新的集合
# 1，用1个for
sb = {i ** 2 for i in sa}
print (sb)
print ("____________________________________")#分隔符
# 2,用2个for循环
se = {m*n for m in sa for n in sa}
print (se)

# 集合的内置函数
# len: 长度
print (len (se))
# max/min ： 最大值/最小值
#add ： 向集合中添加元素

sa = {1,2,3,4,5,6,5,4,3,2,1}
print (sa)
# 向sa中添加数字7 结果打印出来None
print (sa.add(7))
#添加了值并不会在add添加选项中打印出来 如下列
print (sa)
print (sa.add(8))
print (sa)

# clear ： 清空
#删除操作
# remove 与 discard的区别


#remove案例
sa1 = {1,2,3,4,5,6,7,8,9}
print (sa1)
sa1.remove(5)
print (sa1)
print ("____________________________________")#分隔符
#如果remove删除的值并不在集合中就会报错
sa1.remove(5)
print (sa1)

# discard案例
sa1 = {1,2,3,4,5,6,7,8,9}
print (sa1)
sa1.discard(5)
print (sa1)
print ("____________________________________")#分隔符
#如果discard删除的值就不会报错
sa1.discard(5)
print (sa1)

# pop删除集合的一个内容
#删除的内容是随机的
sa1 = {1,2,3,4,5,6,7,8,9}
print (sa1)
sa1.pop()
print (sa1)
sa1.pop()
print (sa1)

# 集合的数学操作
# intersection ： 交集
sa = {1,2,3,4,5,6}
sb = {4,5,6,7,8,9,}
#sa 和 sb 的交集
print(sa.intersection(sb))
# difference ： 差集
print (sa.difference (sb))
#差集的另外一表示
print (sa - sb)

# union ： 并集
print (sa.union(sb))
#并集 不能使用+表示
print (sa + sb)

frozenset 冰冻集合¶
不允许修改的集合

# 案例
print(sa)
sb = frozenset (sa)
print (sb)

递归函数
递归 ： 函数间接或者直接调用自己
递归分两个过程
往下调用，分解过程
往上回溯，综合过程
递归需要注意
一定要有结束条件
是以资源换取编写速度的算法比较吃硬件

def a (n):
    print ("i love una ")
    
def b (n):
    a(100)
    print ("una love gpc")
b(100)

# func_a表示己算阶乘
#利用数学公式
def fun_a(n):
    print (n)
    #递归一定要有结束条件
    if n == 1:
        return 1
    return n * fun_a(n-1)
rst = fun_a(5)
print ("f(5) =  ",rst)

递归必须有结束，负责会死掉报错
def fun_a(n):
print (n)
return n * fun_a(n-1)
rst = fun_a(5)
print ("f(5) = ",rst)

# 斐波那契额数列
#1，1，2，3，5，8，13，21  前两个数列相加
def fib (n):
    if n ==1 or n ==2:
        return 1
    return fib(n-1) + fib(n-2)

jieguo = fib (10)
print ("jieguo=",jieguo)

# 汉诺塔
a = "A"
b = "B"
c = "C"
def hannuo(a,b,c,n):
    if n == 1:
        print ("{}-->{}".format(a,c))
        return None
    if n == 2:
        print ("{}-->{}".format(a,c))
        print ("{}-->{}".format(a,b))
        print ("{}-->{}".format(b,c))
        return None
    hannuo(a,c,b,n-1)
    print ("{}-->{}".format(a,c))
    hannuo(b,a,c,n-1)

# 只有一个盘子
hannuo(a,b,c,1)

hannuo (a,b,c,5)