Python—函数和内置结构：Str,List,Tuple,Dict,Set_str list dict set python内置

一.函数

def func():
    print ("woshi python")

#形参实参
def hello(person):
    print ("{},你好".format(person))
    return None#无返回值的时候
#如果无返回值，系统默认返回了一个None

p = "小敏"
hello(p)

#9乘9乘法表
def chegfabiao(num):
    for o in range(1,num):
        for i in range(1,o+1):
            print(o*i,end= " ")
        print()#每调用一次print，默认一次换行，所以需要改变end的值来改变格式

chegfabiao(12)

#help(print)可以用help函数来了解一个函数的功能


#python  和c++  类似，函数的参数可以设置默认值

def default_num (one , two ,three=10):
    print(one+two)
    print(three)
    return None

default_num(1,2,3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

二.str字符串

#单引号双引号三引号
s= "今天是2019/7/9，刚下过一场雨，天气凉爽"
print(s)

#如果字符串内有单引号，需要使用双引号进行含括+
s = "Let's go"
#s = 'Let\'s go'  使用转义字符也是可以的
print(s)

#以下类型的使用类似C语言，需要使用 %
s= "我今年%d 岁了"
print(s%19)
s= "我今年%d 岁了"%19
print(s)

#以下是通过format 函数来实现

s= "我今{}岁了，他今年{}岁了"
print(s.format(10,20))
# 这里可以规定参数是列表中的第几个
s= "我今{1}岁了，他今年{0}岁了"
print(s.format(10,20))
#这里我们可以设置名称来实现
s = "{name}是百度的ceo，他的网站是{url}，最近因为{thing}上了热搜"
s = s.format(name="李彦宏",url="www.baidu.com",thing="被泼水")
print(s)

#这样子设置也可以完成几位小数的工作
s= "i am {:.2f} m height, {:.2f} kg weight"
print(s.format(60.000,78.055))

#字符串拼接
s= "今天是7/9"+"天气阴"+"有风"
print(s)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#1.find 函数
#用于寻找字符串内是否 有相应的子串

s= "i am houwei ,i am study in NJUPT"
s1= "stu"
print(s.find(s1))
#返回的是第一次发现字符串的地方
s= "i am houwei ,i am study in NJUPT which is in NanJING city"
s2= "N"
print(s.find(s2,30))#这样可以设置起始位置

#rfind lfind,从右从左开始查找

#2.Index函数
#类似于find，在没有发现时会报错
s= "i am houwei ,i am study in NJUPT"
s1= "an"
#s.index(s1)

#3.判断类函数
# isalpha:判断是否是字母
# isdigit:判断是否是数字
#isnumeric:可以判断是否是汉子数字
#islower:判断是否是小写字母
s1="i am chinese"
s2 = "A"
s3= "一二三"
print(s1.isalpha())
print(s2.isalpha())
print(s3.isnumeric())
print()#换行

# #字符串内容判断
#startswith endswith  :检查字符串是否是以某个子串开始或者结束
s1= "I"
s2 = "ok"
s= "I am ok"
print(s.startswith(s1))
print(s.endswith(s2))

#操作类函数
#format:格式化
#strip:删除字符串两边的空格，也可以自定义删除字符串两边的某个字符
#join:进行字符串的拼接
c = "DDDDD,so cool "
print(c.strip(),end="-----")
print()
print(c.strip('D'),end="-----")
#可以从第二个结果看出，第二个结果是删除D，而不是空格

s1 = "$"
s2 = "-"
s3 = " "
s= ["adasdad","asdaxcxcc","vsfgbff"]
print(s1.join(s))
print(s2.join(s))
print(s2.join(s))



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

三.list列表

#一组又先后顺序排列的序列
# 1.数据可以不是一类数据类型
# 2.有先后顺序的

#第一种创建方法
L1 = [1,2,4,5,"西瓜"]
print(L1)

#第二种创建方法
s= "ADCSX AS"
L2 = list(s)
L3 = [s]
print(L2)
print(L3)
#注意这两种的区别

#列表的一些功能
#1.列表的索引，类似于数组的访问
L4=[22,114,55,4,666,4]
print(L4[2])
#也会存在数组访问超标

#2.切片操作
#从原来的列表中截取一段，注意取值范围，是左包括，右不包括
L1= [1,2,3,4,5,6,7,8,9,10]
print(L1[1:6])
print(L1[:4])#下标可以为空
#切片结果是一个列表

#切片可以设置步长，默认值是1
print(L1[::2])#两个冒号后面的值是步长
#结果是[1, 3, 5, 7, 9]

# 下标和步长可以是负值，表示从右往左
# 规定：数组最后一个数字下标为-1
print(L1[-2:-5:-1])
#输出的结果是9，8，7，那如果我们要是输出7 8 9呢？、
print(L1[-4:-1:1])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

四.tuple元组

#可以理解成一个不可以更改的列表

#tuple的创建
#1.
ta = (10)
print(type(ta))#这个样子的ta是int 类型
#如果想要成为元组，可以在后面加个，
tb = (10,)
print(type(tb))

#2.直接用逗号定义，最后面可加可不加逗号
ta = 10,20,25
print(ta)

#3.通过tuple创建
L1 = [1,2,3,4,65,6]
tc = tuple(L1)
print (tc)

#tuple的其他性质和 list 基本一致
# 1.先后顺序
# 2.可以访问不能修改
# 3.元素可以使任意类型
# 4.切片操作
L1 = [1,2,3,4,65,6]
tc = tuple(L1)
print (tc[-1::-1])#反过来输出

#5.元组相加
ta = 10,20,30
tb = ("asdxc","ascc","efgf")
tc =ta+tb
print(tc)

#6.元组的乘法
#效果就是打印几遍元组内的内容
print(ta*2)

#7.元组元素的检测
if 10 in ta :
    print("你在就好")

#8.简单和嵌套元组的访问遍历
#（1）简单元组
for i in ta:
    print(i)
#（2）嵌套元组
td = ( (10,20,30) , ("i","love","wangcxiaojing") , (100,2003,300) )
for i in td:
     print(i)
     for j in i:
         print(j)

#另一种方法，这种方法需要注意个数需要与元组个数一致
for i,j,k in td:
    print(i,j,k)


ta = (10,56,21,65,4,2,4,5,4)
#常用的元组函数
#1.len:计算长度
print(len(ta))
#2.max:打印最大的值，同类型可以比较，不同类型无法比较，比如 str 和 int
print(max(ta))
#3.count:计算元组中某一个元素在里面出现的次数
print(ta.count(4))
#4.index:元组中某一个元素所在的位置，从左往右找，第一个出现的位置
print(ta.index(21))

#tuple 或者说python的特殊用法
a = 100
b = "waaslidhjased"
#要想交换二者的值
a,b = b,a
print(a,b)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

五.set集合

#和数学中的集合概念一致
#内容无序，且内容不重复

#集合的定义
#1.集合set的定义
sa = set()
print(sa)

li = [1,2,3,4,5,1,2,3,4,5,2,3,45,6,2,8,9]
sa = set(li)
print(sa)#自动滤掉重复的元素

#2.大括号定义
sa = {1,23,4,6,1,4,5,12,4,61,1,25,4,2,3,41,3,2,1,3}
print(sa)


#集合的一些操作
#1.in操作，判断某个元素是否在集合中、
if 2 in sa :
    print("Yes")

for i in sa:
    print(i)
#2.当集合中嵌套且元素个数一致的时候
sb = {(2,3,4),("asd","asda","gfg"),(201,50,50)}
for i,j,k in sb:
    print(i,j,k)


#集合的生成式
sa = {1,2,3,4,5,6,7,8,9,10}
sb = {i for i in sa}
#有啥好处呢，我们可以添加条件来生成
sb ={ i for i in sa if i%2 ==0}
print(sb)
#如果想生成每个元素的平方
sc= {i**2 for i in sb}
print(sc)
#也可以添加两个for循环
sd = {m*n for m in sb for n in sb}
print(sd)

#集合的内置函数
# 1.len:集合的长度
# 2.max/min:最大最小值
# 3.add:添加值
sa = {1,2,3,4,5,6}
sa.add(7)
print(sa)
# 4.remove和discard
sa.remove(2)
print(sa)
#remove如果删除的值不在集合中，会报错，而discard却不会
# 5.pop 从集合中弹出一个元素，随机的
sa.pop()
print(sa)


#集合的数学操作
# 1.intersection:交集
sa = {1,2,3,4,5}
sb = {4,5,6,7,8,9}
print(sa.intersection(sb))
# 2.difference：差集
print(sa.difference(sb))
print(sa-sb)#这种方法也是可以的
# 3.union：并集
print(sa.union(sb))
#并集不能使用+ 号进行计算
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

六.dict字典

#字典
#字典是一种组合数据，没有顺序的组合数据，数据以键值对出现

#字典的创建
d = {}
print(d)

d = dict()
print(d)

d= {"one":1,"two":2,"three":3}
print(d)

d= dict(one=1,two=2,three=3)
print(d)

d= dict([("one",1),("two",2),("three",3)])
print(d)

#字典的特征
# 字典是序列类型，但是没有分片，没有索引
# 字典中的数据都是由键值对组成
# key:值必须是可以hash的，int string float tuple 不能是list set dict
# value：任何值

#访问数据
d= {"one":1,"two":2,"three":3}
print(d["one"])

#修改value
d["one"] = "envis"
print(d)

#删除数据
del d["one"]
print(d)

#成员检测 in，not in,检测的是key
d= {"one":1,"two":2,"three":3}
if "one" in d:
    print(d["one"]);

for k in d:
    print(k,d[k])

for k in d.keys():
    print(k)

for v in d.values():
    print(v)

for k,v in d.items():#注意这种用法
    print(k,"--",v)


#字典生成式
d= {"one":1,"two":2,"three":3}
dd = {k:v for k,v in d.items()}
print(dd)
#我们也可以加上限制条件
dd = {k:v for k,v in d.items() if v%2== 0}
print(dd)


##字典相关函数
#通用函数：len max min dict
#str(字典）：返回字典的字符串格式
print(str(d))

#clear:清空字典

#items：返回字典键值对组成的元组格式
print(d.items())
print(type(d.items()))
#是一个元组格式

#keys：返回字典的键组成的一个结构
print(d.keys())

#values：返回字典的值组成的一个结构
print(d.values())


#get:可以根据指定的键返回值，好处是可以设置默认值
print(d.get("one333"))
#比较下面两个的区别
print(d.get("one",100))
print(d.get("one33",100))
#如果存在，则返回相应的值，如果不存在，在返回设置的默认值


#fromkeys:使用指定的序列作为键值，使用一个值作为字典的所有键的值
l = ["asdasd","cicici","ukws tasdhnf"]
d= dict.fromkeys(l,"xixixi")
print(d)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

七.递归函数及汉诺塔问题

def fab(n):
    if n == 1:
        return 1
    return n*fab(n-1)

print(fab(5))

#斐波那契数列
def fib(n):
    if n == 1 or n == 2:
        return 1
    return fib(n-1)+fib(n-2)

for i in range(1,15):
    print(fib(i),end=" ")


#汉诺塔问题
def hanoi(a,b,c,n):
    if n==1:
        print("{}-->{}".format(a,c))
        return None
    if n==2:
        print("{}-->{}".format(a, b))
        print("{}-->{}".format(a, c))
        print("{}-->{}".format(b, c))
        return None

    hanoi(a,c,b,n-1)
    print("{}-->{}".format(a, c))
    hanoi(b,a,c,n-1)

hanoi('A','B','C',3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33