1.变量、2.运算符、3.分支与循环、4.列表与元组、5.字符串处理、6.字典与集合 、7.变量值与内存、8.函数
1.变量
# 单行注解使用井号
"""
三个双引号
或
三个单引号
为多行注释
"""
'''
三个双引号
或
三个单引号
为多行注释
'''
studentid='a123'
studentname='tom'
print("studentid:",studentid," studentname:",studentname)
price=50.5
weight=4.5
sum=price*weight
print("总价格为",price,"*",weight,"=",sum)
"""判断类型"""
a1=10
a2=10.5
a3=True
a4=False
a5="你好"
a6=[1,2,3,4,5,6,7,8,9]
a7=(1,2,3,4,5,6,7,8,9)
a8={'name':'tom','age':18}
a9={1,2,3,4,5,6,7}
print(type(a1))
print(type(a2))
print(type(a3))
print(type(a4))
print(type(a5))
# list相当于 java中的数组
print(type(a6))
# 元组属于不可变列表 此数据类型java中无对应类型
print(type(a7))
# 字典相当于java中的map集合
print(type(a8))
# 集合相当于java中的集合
print(type(a9))
# list与set区别
# 1.有序与无序 过后拓展******************
b1=10
b2=True
b3=False
print("10+True=",b1+b2)
print("10+False",b1+b3)
c1 = "aaaa"
c2 = "bbbb"
print(c1+c2)
c3 = 123
print(c1+str(c3))
print("a"*3)
d1 = "111"
d2 = "222"
d3 = "333.4"
print(d1+d2)
print(int(d1)+int(d2))
print(int(d1)+float(d3))
# 真假
e1 = 0.1
e2 = 0
print(bool(e1))
print(bool(e2))
# list tuple
f1 = "123456"
print(list(f1))
print(type(list(f1)))
print(tuple(f1))
print(type(tuple(f1)))
# dict set
f2 = "123"
f3 = '{"name":"yct","age":10}'
print(set(f1))
print(type(set(f1)))
# print(dict(f3))
# print(type(dict(f3)))
print(eval(f3))
print(type(eval(f3)))
# 练习
ap = input("apple price")
aw = input("apple weight")
print("总价为"+str(int(ap)*int(aw)))
# c风格输出 %类似java中的反斜杠 为转义字符 与c语言的输出格式类似
g1=10
g2=10.5
g3=True
g4="你好"
g5=[1,2,3,4,5,6]
g6="%"
print("g1 is %d g2 is %.2f g3 is %s g4 is %s g5 is %s g6 is %s and %% "%(g1,g2,g3,g4,g5,g6))
# format 字符串升级写法
print("format1 g1 is {} g2 is {} g3 is {} g4 is {} g5 is {} g6 is {} ".format(g1,g2,g3,g4,g5,g6))
print(f"format2 g1 is {g1} g2 is {g2} g3 is {g3} g4 is {g4} g5 is {g5} g6 is {g6}")
hname = input("请输入姓名:")
hcompany = input('公司名称')
hjob = input('请输入职位')
hemail=input('邮箱')
htel=input('电话')
print("*"*50)
print(hcompany+"\n")
print(f"{hname}({hjob})\n")
print(f"邮箱:{hemail}")
print(f"电话:{htel}")
print("*"*50)
2.运算符
a1=True
a2=False
a3=0
a4=1
a5=2
"""
与java不同的运算符
1除法自动得小数 想实现取整数 需要使用 //
2有乘方(幂) 符号为 **
"""
print("10**3=",10**3)
print("10/3=",10/3)
print("10//3=",10//3)
print(a1+a2)
print(a1==a2)
# 1 是true
print(a1==a4)#True
print(a1==a5)#False
# 取反在python中使用not 在java中使用 !
# True 不一定为1 非0 皆真
if(a5):
print(f"{a5} is True")
if(not a2):
print(f"{a2} is false")
# 逻辑运算符
'''
逻辑运算符与java不同处
1. 取反在python中使用not 在java中使用 !
2. 当为真假时为短路运算
3. 当为数字时
# 判断变量是否为0, 是0则为False,非0判断为True,
# and中含0,返回0; 均为非0时,返回后一个值,
2 and 0 # 返回0
2 and 1 # 返回1
1 and 2 # 返回2
# or中, 至少有一个非0时,返回第一个非0,
2 or 0 # 返回2
2 or 1 # 返回2
0 or 1 # 返回1
'''
print("False and 10/0:",False and 10/0)
print("1 and 0:",1 and 0)
print("0 and 2:",0 and 2)
print("1 and 2:",1 and 2)
print("0 or 2 or 3:",0 or 2 or 3)
print("1 and 2 or 3:",1 and 2 or 3)
print("3 or 1 and 2 :",3 or 1 and 2)
print("(3 or 1) and 2 :",(3 or 1) and 2)
print("1 & 2:",1 & 2)
print("1 | 2:",1 | 2)
3.分支与循环
a1=10
a2=20
"""
if条件与java使用方法一直,语法关键词稍有不同java else if ----python elif
python中无switch语句
"""
if a1==10:
print("*"*10+"a1==10")
if a1==15:
print("*"*10+"a==15")
else:
print("*"*10+"a!=15")
if a1==10:
print("*"*10)
elif a2==20:
print("#"*10)
elif a1==10 and a2==20:
print("^"*10)
"""
循环 与java逻辑一致
yujava不同点 当没有表达式时 java {} python pass
"""
# 1+2.....+100
b1=0
bsum1=0
while b1<=100:
bsum1=bsum1+b1
b1=b1+1
print(bsum1)
# 大于1000时终止
b2=0
bsum2=0
while b2<=100:
if bsum2>1000:
break
else:
bsum2=bsum2+b2
b2=b2+1
print(bsum2)
# 1+3+5.....99
b3=0
bsum3=0
while b3<=99:
if b3%2==0:
b3=b3+1
continue
elif 1==2:
pass
else:
bsum3=bsum3+b3
b3=b3+1
print("bsum3:"+str(bsum3))
"""
for 循环 与Java不同 类似java中的 foreach语句
for(in)
"""
# 遍历字符串
for n in "hello how are you":
print(n)
# 遍历数字 利用range(m,n)函数 其实m 共打印 n-m个 最大值为 n-1
for n in range(1,5):
print(n)
"""
9*9 算法表
1*1=1 k1=1 t1=1 规律: t1*k1
1*2=2 2*2=4 k1=2 t1=1 /t1=2
1*3=3 2*3=6 3*3=9 k1=3 t1=1/t1=2/t1=3
...
利用print 打印 自动换行 如果不想换行 使用 end="" 可以不换行
"""
for k1 in range(1,10): #行
for t1 in range(1,k1+1): #列
result=t1*k1
print(f"{t1}*{k1}={result}\t",end="")
print()
"""
随机生成数与java 不同 python随机生成的为左闭右闭 java 生成为随机数 左闭右开
"""
import random
# random.randint(a, b) ,返回 [a, b] 之间的整数,包含 a 和 b
k=1
while k<100:
n2 = random.randint(1, 10)
print(n2,end=",")
k=k+1
4列表与元组
"""
列表 list
与java中的ArrayList类似
写法与java数组类似
"""
al=[1,2,3,4,5,6,7,8]
# 遍历list
for n in al:
print(n)
# 字符串转 list
a2="hello how are you"
print(list(a2))
# list 转字符串
a3=['h', 'e', 'l', 'l', 'o', ' ', 'h', 'o', 'w', ' ', 'a', 'r', 'e', ' ', 'y', 'o', 'u']
a4=""
for n in a3:
a4=a4+n
print(a4)
# 删除list 及元素
del a3[0]
print(a3)
# del a3
# print(a3) //list已删除
# 列表元素处理 append添加到最后 insert 插入到其中 extend将list插入
# 以上为使用原地址进行拼接 -----原地操作
b1=[1,2]
print(b1)
b1.append(3333)
print(b1)
b1.insert(0,9)
print(b1)
b1.extend([7,6,5])
print(b1)
# list改变地址操作 即新生成地址 ----返回新列表
b2=[1,2]
print("br2:"+str(b2))
b3=b2+[3]
print("br3"+str(b3))
# pop 弹出栈尾 remove 删除指定位置元素(比index大一) clear 清空list del 删除指定下表index位置元素
b3=[1,2,3,4,5,6,7,8]
print(b3)
print(b3.pop())
print(b3)
print(b3.remove(1))#删除第一个
print(b3)
print(b3.clear())
print(b3)
b4=[1,2,3,4,5,6,7,8,1]
print(b4)
del b4[1]
print(b4)
# 列表访问技术 count计数 in判断是否有 in
print(b4.count(1))
# 判断是否有可以用两种方法 count为0 说明无 in 返回 bool
print(b4.count(9))
print(9 in b4)
# sort 排序
b5=[78,2,6,8,3,1,45,21,23]
print(b5.sort()) #默认升序
print(b5)
# 降序三种方法
# 方法一
# b5.sort(reverse=True)
# print(b5)
# 方法二
# b5.sort()
# # b5.reverse()
# print(b5)
# 方法三
# b5.sort()
# print(list(reversed(b5)))
# 返回可迭代的zip对象 用法后续拓展
# 返回带下表index的枚举对象
b6="hello"
b7=enumerate(list(b6))
print(b7)
for k in b7:
print(k)
# 遍历列表三种方式
b8=list(b6)
for k in b8:
print(k,end="")
print()
#range(0,n)与 range(n)等价
for k in range(len(b8)):
# for k in range(0,len(b8)):
print(b8[k],end="")
print()
# 遍历枚举类型多个参数值 第一个为下表 第二个参数为值
for i,ele in enumerate(b8):
print(f"{i} : {ele}")
'''
列表推导式 java中无此方法
lis = [i for i in range(100)]
print(lis)
result=[]
for i in range(100)
result.append(i)
'''
lis1 = [i for i in range(100)]
print(lis1)
result2=[]
for i in range(100):
result2.append(i)
print(result2)
'''
vec = [[1,2,3], [4,5,6], [7,8,9]]
list2=[num for elem in vec for num in elem]
result3=[]
相当于
for elem in vec:
for num in elem:
result3.append(num)
'''
vec = [[1,2,3], [4,5,6], [7,8,9]]
list2=[num for elem in vec for num in elem]
print(list2)
result3=[]
for elem in vec:
for num in elem:
result3.append(num)
print(result3)
# 过滤
# 将大于0的重新放到新数组里
'''
aList = [-1,-4,6,7.5,-2.3,9,-11]
list4 =[ n for n in aList if n>0 ]
相当于
result4=[]
for n in aList:
if n>0:
result4.append(n)
'''
aList = [-1,-4,6,7.5,-2.3,9,-11]
list4 =[ n for n in aList if n>0 ]
print(list4)
result4=[]
for n in aList:
if n>0:
result4.append(n)
print(result4)
"""
print([(x, y) for x in range(3) for y in range(3)])
list6=[]
for x in range(3):
for y in range(3):
list6.append((x,y))
"""
print([(x, y) for x in range(3) for y in range(3)])
list6=[]
for x in range(3):
for y in range(3):
list6.append((x,y))
print(list6)
"""
print([(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y])
list7=[]
for x in [1, 2, 3]:
for y in [3, 1, 4]:
if x != y
list7.append((x,y))
"""
print([(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y])
list7=[]
for x in [1, 2, 3]:
for y in [3, 1, 4]:
if x != y:
list7.append((x,y))
print(list7)
'''
解决冒泡排序问题
实现从小到大排序
'''
alist5 = [45,32,31,12,5,2,18,49,1]
for m in range(1,len(alist5)):
for n in range(0,len(alist5)-m):
if alist5[n]>alist5[n+1]:
temp= alist5[n]
alist5[n]=alist5[n+1]
alist5[n+1]=temp
print("alist5:"+str(alist5))
# 切片
'''
这里的索引与java不同 java无负值 python可以设置负值从右向左
python中的有序序列都支持切片,如字符串,元组,列表。
'''
colors = ["red", "blue", "green"]
print(colors[-1])
'''
li[start : end : step]
默认 step为1
如果不写前或尾 自动从前到尾
如果 右超出界限 自动到当前最大值
方向
step = 1
---------------------->
-4 -3 -2 -1
["A", "B", "C", "D"]
0 1 2 3
step=-1
<--------------------
[0,2]
从0开始 共2-0个元素
'''
li = ["A", "B", "C", "D"]
t=li[0:3] # ["A","B","C"] #起点的0索引可以省略,t=li[:3]
print(t)
t=li[2: ] # ["C","D"] #省略end,则切到末尾
print(t)
t=li[1:3] # ["B","C"]
print(t)
t=li[0:4:2] #$ ["A","C"] #从li[0]到li[3],设定步长为2。
print(t)
t=li[0:2]
print(t)
t=li[0:-2]
print(t)
t=li[-4:-2]
print(t)
t=li[-4:2]
print(t)
t=li[-1:-3:-1]
print(t) #d c
t=li[::-1] # t--->["C","B","A"] #反向切,切出全部
t=li[:] # t--->["A","B","C","D"] #正向切全部
# 使用切片来原地修改列表内容
alist6=[1,2,3,4,5,6]
# 后增加 7,8,9
alist6[len(alist6):]=[7,8,9]
print(alist6)
# 将前三个换为8,9
alist6[:3]=[8,9]
print(alist6)
# 删除前三个
# 方法一
alist6[:3]=[]
print(alist6)
#方法二
del alist6[:3]
print(alist6)
#删除偶数位的元素
alist7=[1,2,3,4,5,6,7,8,9,10]
del alist7[1::2]
print(alist7)
'''
浅层复制与深层复制问题后续拓展
https://baijiahao.baidu.com/s?id=1597371058109891101&wfr=spider&for=pc
'''
'''
元组 tuple 元组属于不可变序列(元素集合),一旦创建,
用任何方法都不可以修改其元素。从形式上,元组的所有元素放在一对 圆括 ()号中,
元素之间用逗号分隔。
'''
c1=(1,2,3,4,5,6)
print(tuple("hello")) #把字符串转换为元组
print(tuple(list("hello"))) #把列表转换为元组
5.字符串处理
'''
字符串操作
'''
#切片方法 同 list中的切片
s1 = 'www.neuedu.com'
print(s1[6: 10])
s2 = 'www.NEUEDU.com'
print(s2.upper()) #### 全部大写
print(s2.lower()) #### 全部小写
s3 = 'www.neuedu.com'
print(s3.startswith('www')) #### 判断是否以www开头
print(s3.endswith('com')) #### 判断是否以com结尾
#find找不到-1 index找不到报错
s4 = 'chhengt'
print(s4.find('h')) #### 通过元素找索引找到第一个就返回(可切片)
print(s4.find('b')) #### 找不到返回 -1
# print(s4.index('b')) #### 找不到会报错
s5 = 'qqwalex qqwusir barryy'
print(s5.strip('qqw'))
print(s5.strip(''))
print(s5.lstrip('yy'))
print(s5.rstrip('yy'))
# split 把字符串分割成列表
s61 = 'qqwalex qqwusir barryy'
s62 = 'qqwale;x qqwu;sir bar;ryy'
print(s61.split()) #### 默认以空格分割
print(s62.split(';')) #### 以指定字符分割
print(s62.split(';', 1)) #### 指定分割多少个
#列表转字符串 join
li = ['aa', 'ddj', 'kk']
print("".join(li))
print(",".join(li))
str=""
for n in li:
str=str+n;
print(str)
#### 字符串.isalnum() 所有字符都是数字或者字母,为真返回 Ture,否则返回 False。
#### 字符串.isalpha() 所有字符都是字母,为真返回 Ture,否则返回 False。
#### 字符串.isdigit() 所有字符都是数字,为真返回 Ture,否则返回 False。
#### 字符串.islower() 所有字符都是小写,为真返回 Ture,否则返回 False。
#### 字符串.isupper() 所有字符都是大写,为真返回 Ture,否则返回 False。
#### 字符串.istitle() 所有单词都是首字母大写,为真返回 Ture,否则返回 False。
#### 字符串.isspace() 所有字符都是空白字符,为真返回 Ture,否则返回 False。
#### is 系列
name = 'taibai123'
print(name.isalnum()) # True #### 字符串由数字或字母组成时返回真
print(name.isalpha()) # False #### 字符只由字母组成时返回真
print(name.isdigit()) # False #### 字符只由数字组成时返回真
#### count 计算字符串中某个字符出现的次数 ***
s = 'www.neuedu.com'
print(s.count('u'))
print(s.count('u', 7))
#replace
s = 'asdf 之一,asdf也,asdf'
#### replace ***
s1 = s.replace('asdf', '日天')
print(s1)
s1 = s.replace('asdf', '日天', 1)
print(s1)
#### format 格式化输出 ***
#### 第一种方式:
s = '我叫{}, 今年{}, 性别{}'.format('小五', 25, '女')
print(s)
#### 第二种方式
s1 = '我叫{0}, 今年{1}, 性别{2},我依然叫{0}'.format('小五', 25, '女')
print(s1)
#### 第三种方式
s2 = '我叫{name}, 今年{age}, 性别{sex},我依然叫{name}'.format(age=25, sex='女',name='小五')
print(s2)
#第四种方式
age=25
sex='男'
name='小浏览器'
s3=f'我叫{name}, 今年{age}, 性别{sex},我依然叫{name}'
print(s3)
s = 'chen wuang4fhsa¥fh。f'
#### capitalize() 首字母大写 **
s1 = s.capitalize()
print(s1)
#center() 将字符串居中可以设置总长度,可以设置填充物 * 默认空格填充
s = 'chenziwu'
s2 = s.center(50)
print(s2)
s2 = s.center(50, '*')
print(s2)
# title 非字母隔开的每个单词的首字母大写 *
s = 'chen wuang4fhsa¥fh。f'
#### title 非字母隔开的每个单词的首字母大写 *
s4 = s.title()
print(s4)
# 字符串是不可变变量,不支持直接通过下标修改
msg = 'abcdefg'
# msg[2] = 'z' //不可通过下表修改
msg = msg[:2] + 'z' + msg[3:]
print(msg)
6.字典与集合
"""
字典类型
相当于java中的map集合
"""
a_dict={"name":"tom","age":11}
print(a_dict["name"])
keys = ['a', 'b', 'c', 'd']
values = [1, 2, 3, 4]
print(zip(keys, values)) #元组压缩
# zip 转 dict
print(dict(zip(keys, values)))
print(type(dict(zip(keys, values))))
print(list(zip(keys, values)))
# list->tuple 转 dict
print(dict(list(zip(keys, values))))
#特殊写法 转 dict
d = dict(name='Dong', age=37)
print(d)
#list-> 紧有key的dict
print(dict.fromkeys(["username","password"]))
print(zip(*zip(keys, values))) #解压 回归二维矩阵
print(list(zip(*zip(keys, values))))
a1,b1=list(zip(*zip(keys, values)))
print(a1)
print(b1)
aDict = {'name':'Dong', 'sex':'male', 'age':37}
# aDict['name']键不存在,抛出异常
# 使用字典对象的get方法获取指定键对应的值,并且可以在键不存在的时候返回指定值。
print(aDict['name'])
print(aDict.get("name"))
# print(aDict['name1'])
print(aDict.get("name1","null"))
aDict={'age': 37, 'name': 'Dong', 'sex': 'male'}
aDict['score'] = aDict.get('score',[])
aDict['score'].append(98)
aDict['score'].append(97)
print(aDict)
# items()方法可以返回字典的键、值对列表
print(aDict.items()) # dict_items([('age', 37), ('name', 'Dong'), ('sex', 'male'), ('score', [98, 97])])
t1=('a','b','b');
for key in aDict: #不加特殊说明,默认输出键
print(key)
print(aDict.keys())
print(aDict.values())
# 使用字典对象的setdefault()方法返回指定“键”对应的“值”,如果字典中不存在该“键”,就添加一个新元素并设置该“键”对应的“值”
aDict ={'name' : 'Wang','sex' : 'male'}
aDict.setdefault('age','28')
print(aDict)
print(aDict.setdefault('age'))
print(aDict.setdefault('hobby'))
print(aDict)
#
aDict={'age': 38, 'name': 'Dong', 'sex': 'male'}
aDict['address'] = 'SDIBT' #增加新元素
print(aDict)
# 使用字典对象的update方法将另一个字典的键、值对添加到当前字典对象
aDict.update({'a': 'a', 'b': 'b'})
print(aDict)
'''
字典删除
使用del删除整个字典,或者字典中的指定元素
使用pop()和popitem()方法弹出并删除指定元素
使用clear()方法清空字典中所有元素
'''
x={}
x['name']="tom"
x['age']=20
print(x)
x.clear()
print(x)
x={}
x['name']="tom"
x['age']=20
print(x)
print(x.popitem())
print(x)
# 判断key是否在字典中
d = {'name':'tom', 'age':10, 'Tel':110}
print(d.keys())
print ('name' in d.keys())
print ('age' in d)
print("---------------------------------")
# 遍历dict集合思路
# 遍历key值 获得value值
for key in d:
print(key+" "+str(d[key]))
print("---------------------------------")
for key in d.keys():
print(key + " " + str(d[key]))
print("---------------------------------")
# 获得value值
for value in d.values():
print(value)
print("---------------------------------")
# 获得item 分别获得key值与value值
print(d.items())
for key,value in d.items():
print(key+" "+str(value))
print("--------------------------------- 用[] 来降维")
for item in d.items():
print(item[0]+" "+str(item[1]))
print("---------------------------------")
for (key,value) in d.items():
print(key+':'+str(value))
# 向dict添加元素极其顺序 目前加入顺序与数据结构顺序一致
x = dict()
y = {}
print(x)
print(y)
x['a'] = 3
x['c'] = 8
x['b'] = 5
print(x)
import collections
x =collections.OrderedDict()
x['a'] = 3
x['c'] = 8
x['b'] = 5
print(x)
for item in x:
print(item+" "+str(x[item]))
'''
字典推倒式
{ key_expr: value_expr for value in collection if condition }
相当于
for value in collection:
if condition:
d[value[1]]=value[0]
'''
strings = ['import','is','with','if','file','exception','liuhu']
d = {key: val for val,key in enumerate(strings)}
print(d)
d={}
for val, key in enumerate(strings):
d[key]=val
print(d)
d={}
for item in enumerate(strings):
print(item)
d[item[1]]=item[0]
print(d)
# 输出key字符 value为其长度
s = {strings[i]: len(strings[i]) for i in range(len(strings))}
print(s)
k = {k:len(k)for k in strings}
print(k)
# 练习:同一个字母但不同大小写的值合并起来了。
mc = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
mca = {k.lower(): mc.get(k.lower(), 0) + mc.get(k.upper(), 0) for k in mc.keys()}
print(mca)
mcb={}
for k in mc.keys():
mcb[k.lower()]= mc.get(k.lower(),0)+mc.get(k.upper(),0) # mc.get(k.lower(),0) 后面的0 是如果为none就是0
print(mcb)
# 集合set相当于java中的collection 下的无序集合 每次输出都可能不同!
# 自动去除重复 无序
a = {3, 5}
a.add(7)
a.add(2)
a.add(3)
a.add(4)
a.add(6)
print(a)
a=set()
print(a)
# add remove pop del(无当前空间未定义再次调用会报错) clear(清空)
a = {1, 4, 2, 3}
print(a)
print(a.pop())
print(a.pop())
a.remove(3)
print(a)
a.clear();
print(a)
a = {1, 4, 2, 3}
# del a
# print(a)
# update()来使一个集合加入到当前集合中
a.update({9,8,7,6,5})
print(a)
#list---->set
a_set = set([8, 9, 10, 11, 12, 13])
b_set = {0, 1, 2, 3, 7, 8}
# 并集
print(a_set | b_set)
a_set.union(b_set)
print(a_set.union(b_set))
#交集
print(a_set & b_set)
print(a_set.intersection(b_set))
#差集
print(a_set - b_set)
print(a_set.difference(b_set))
#子集
x={1,2,3}
y={1,2,3,4}
print(x.issubset(y)) #子集
print(x < y) #真子集
import random
#随机选择1~500之间的数
print(random.choice(range(500)))
# 快速生成 100个1~500的随机数
listRandom = [random.choice(range(500)) for i in range(100)]
print(listRandom)
# 将里面的单一元素进行提取
noRepeat = []
for i in listRandom:
if i not in noRepeat:
noRepeat.append(i)
print(noRepeat)
newSet1 = set(listRandom)
newSet2 = set(noRepeat)
print(newSet1)
print(newSet2)
# 集合推导
s = {x.strip() for x in (' he ', 'she ', ' I')}
print(s)
# 统计单词出现的频次
word="I'm a boby, I'm a girl. When it is true, it is ture. that are cats, the red is red."
word=word.replace(',','').replace('.','')
word=word.split()
print(word)
print('第1种方法')
setword=set(word)
for i in setword:
count=word.count(i)
print(i,'出现次数:',count)
print('第2种方法')
dict = {}
for key in word:
dict[key] = dict.get(key, 0) + 1
print(dict)
print('第3种方法')
from collections import Counter
result = Counter(dict)
print(result)
print(result.most_common(3))
# 奥运会足球分组
# # 已知有十六支男子足球队参加2008 北京奥运会。写一个程序,把这16 支球队随机分为4 个组。采用List集合和随机数
# #
# # 2008 北京奥运会男足参赛国家:
# #
# # 科特迪瓦,阿根廷,澳大利亚,塞尔维亚,荷兰,尼日利亚,日本,美国,中国,新西兰,巴西,比利时,韩国,喀麦隆,洪都拉斯,意大利
# #
# # 提示:分配一个,删除一个
# // map,保存最终分组结果
# // key保存的是第几组,value是该组对应的国家集合
import random
groupNum2Countrys = {}
strCountrys = "科特迪瓦,阿根廷,澳大利亚,塞尔维亚,荷兰,尼日利亚,日本,美国,中国,新西兰,巴西,比利时,韩国,喀麦隆,洪都拉斯,意大利";
countryList = strCountrys.split(",")
for i in range(4):
lstGroup = []
# // 分第1组
# // 随机从集合中选出一个国家,放到第1组里;然后将这个选出的国家,从原来集合中干掉(删除)
# // 重复以上步骤4次
for j in range(4):
selectIndex = random.randint(0,len(countryList)-1)
lstGroup.append(countryList[selectIndex])
countryList.remove(countryList[selectIndex])
groupNum2Countrys[i+1] = lstGroup
for key,value in groupNum2Countrys.items():
print('第' + str(key) + '组')
print(value)
7.变量值与内存
'''
== 运算符比较两个对象的值(对象中保存的数据),而 is 比较对象的引用(标识)。 通常,我们关注的是值,而不是标识,因此 Python 代码中 == 出现的频率比 is 高。
java中我们常说 .equals是值 == 是地址
python中 == 是值 is 是地址
'''
charles = {'name': 'Charles L. Dodgson', 'born': 1832}
lewis = charles
alex = {'name': 'Charles L. Dodgson', 'born': 1832, 'balance': 950}
print(lewis is charles) #True 地址相同
print(alex == charles) #False 值不同
print(alex is not charles ) #alex 与charles地址不同
'''
传参数 可以用贴标签来理解
'''
def f1(a,b):
a+=b
return a
x=1
y=2
print(f1(x,y))
print(x)
def f1(a,b):
a+=b
return a
x=(1,2)
y=(3,4)
print(f1(x,y))
print(x)
x=[1,2]
y=[3,4]
print(f1(x,y)) #原地址不变
print(x)
'''
不可变类型,内存中的数据不允许被修改:
数字类型 int, bool, float, complex, long(2.x)
字符串 str
元组 tuple
可变类型,内存中的数据可以被修改:
列表 list
字典 dict
自定义类型(class定义的类型,后面讲到)
此处可以类比java中在堆内存中 被修改 地址不变,而栈内存中 数据不可修改 当发生变化地址改变
'''
8.函数
#定义函数
def chengji(a,b):
return a*b
print(chengji(2,3))
# 函数的好处 重用
#替换第三个元素
msg = 'abcdefg'
msg = msg[:2] + 'z' + msg[3:]
print(msg)
msg = '1234567'
msg = msg[:2] + '9' + msg[3:]
print(msg)
def insertn(msg,k):
return str(msg[:2])+str(k)+str(msg[3:])
print(insertn("123456",9))
#函数调用 特殊用法
'''
1.调用顺序可调 使用参数赋值
2.使用默认参数可不赋值
3.不定长参数
3.1未命名 *abc 变量为tuple元组
3.2命名 **abc dict 字典
'''
def f(name,age):
print(name+":"+str(age))
f("tom",19)
f(age=18,name="jerry")
#默认参数
def print_info(name,age,sex="male"):
print(name+":"+str(age)+":"+sex)
print_info("tomcat2",2)
print_info("tomcat1",2,"female")
def a(*tuplea):
print(tuplea)
a(1,23,4,5,67)
def a(**abc):
print(abc)
a(name="tom",age=12)
def print_info(name,*args,**kwargs):#def print_info(name,**kwargs,*args):报错 * 在前 **在后
print('Name:%s'%name)
print('args:',args)
print('kwargs:',kwargs)
#传值时注意 后面的nickname内部不要与name重名
print_info("tom",1,2,3,4,nickname="tom",key="asdf")
#将set 与dict 解析 分别使用* 与**
print_info("jerry",*{1,23,4,5},**{"nickname":"aaa"})
# 函数的返回值
'''
return多个对象,解释器会把这多个对象组装成一个元组作为一个整体结果输出
这里与java不同java不能返回多个对象
'''
def f():
return 1,2
print(f())
'''
高阶函数
接受一个或多个函数作为输入 输出一个函数
java中无此用法 类似javascript语法
'''
def a(k):
return k+1
def b(b,a):
return a(b)
print(b(10,a))
def add(x, y, f):
return f(x) + f(y)
res = add(3, -6, abs)
print(res)
"""
变量获得方法
"""
def method():
x = 2
def double(n):
return n * x
return double
fun = method()
print(type(fun)) #class function
num = fun(20)
print(num)
'''
变量作用域
'''
x = str(100) # int built-in
print('hello' + x)
g_count = 0 # global
def outer():
o_count = 1 # enclosing
def inner():
i_count = 2 # local
print(o_count)
# print(i_count) 找不到
inner()
outer()
"""
python中作用域与java不同
在Python中,只有模块(module),类(class)以及函数(def、lambda)才会引入新的作用域,
其它的代码块(如if、try、for等)是不会引入新的作用域的
"""
if(1==1):
x=10
print(x)
def test():
x = 2
print(x) # NameError: name 'x2' is not defined
"""
# 错误的原因在于print(x)时,解释器会在局部作用域找,会找到x=5(函数已经加载到内存),但x使用在声明前了,所以报错:
# local variable 'x' referenced before assignment.如何证明找到了x=5呢?简单:注释掉x=5,x=6
# 报错为:name 'x' is not defined
global 可以将变量声明在全局变量 位置
"""
x=6
def f2():
# print(x)
# global x
# nonlocal x
x=5
# x=x+1
f2()
print(x)
def f4():
y = 6
def f3():
nonlocal y
y=5
# x=x+1
f3()
print(y)
f4()
# print(y)
'''
递归函数
'''
def factorial_new(n):
if n==1:
print("1=",end="")
return 1
else:
print(f"{n}*",end="")
return n*factorial_new(n-1)
print(factorial_new(6))
def fibo_new(n):#n可以为零,数列有[0]
if n <= 1:
return n
return(fibo_new(n-1) + fibo_new(n-2))
print(fibo_new(10))
# 匿名函数
# def f(x,y):
# temp=x
# x=y
# y=temp
# return (x,y)
f=lambda x,y:x if x>y else y
print(f(3,2))
# 求列表[1,2,3,4,5,6,7,8,9],返回一个n*n 的列表
li=[1,2,3,4,5,6,7,8,9]
listn=[]
for num,n in enumerate(li):
listn.append(n**2)
print(listn)
li=[1,2,3,4,5,6,7,8,9]
# listn=[]
for num,n in enumerate(li):
li[num]=n*n
# listn[num]=n*n #IndexError: list assignment index out of range
print(str(num)+":"+str(n))
print(li)
li=[1,2,3,4,5,6,7,8,9]
# map()函数接收两个参数,一个是函数,一个是Iterable,map将传入的函数依次作用到序列的每个元素,并把结果作为新的Iterator返回
print(list(map(lambda x:x**2 ,li)))
# reduce把一个函数作用在一个序列[x1, x2, x3, ...]上,这个函数必须接收两个参数,reduce把结果继续和序列的下一个元素做累积计算,其效果就是:
# reduce(func,[1,2,3]) 等同于 func(func(1,2),3)
# 1*2......9 累乘
from functools import reduce
li=[1,2,3,4,5,6,7,8,9]
print(reduce(lambda x,y:x*y,li))
# filter()也接收一个函数和一个序列。和map()不同的是,filter()把传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留还是丢弃该元素。
# 在一个list中,删掉偶数,只保留奇数
li = [1, 2, 4, 5, 6, 9, 10, 15]
print(list(filter(lambda x:True if x%2==1 else False ,li)))
# 回数是指从左向右读和从右向左读都是一样的数,例如12321,909。请利用filter()筛选出回数
#方法一
print(list(filter(lambda x:True if list(str(x))==list(reversed(str(x))) else False ,list(range(1000)))))
print(list(filter(lambda x:True if str(x)==str(x)[::-1] else False ,list(range(1000)))))
#方法二
str1="abcd"
print(str1[::-1])
# sorted函数 接收一个key函数来实现对可迭代对象进行自定义的排序
# 可迭代对象:主要与列表,字符串,元祖,集合和字典
# key:接受一个函数,根据此函数返回的结果,进行排序
# reverse:排序方向,默认为从小到大,reverse=True为逆向
# 对列表按照绝对值进行排序
li= [-21, -12, 5, 9, 36]
print(sorted(li,key=lambda x:abs(x),reverse=False))
# 把下面单词以首字母排序
li = ['bad', 'about', 'Zoo', 'Credit']
#方法1 指定位置
print(sorted(li, key = lambda x : x[0]))
#方法2 切片
print(sorted(li, key = lambda x : x[:1]))
#按字母顺序
print(sorted(li, key = lambda x : str(x)[0:1].lower()))
# 假设我们用一组tuple表示学生名字和成绩:
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
# 请用sorted()对上述列表分别按名字排序
print(sorted(L,key=lambda x:x[0]))
# 再按成绩从高到低排序
print(sorted(L,key=lambda x:x[1],reverse=True))
"""
函数式编程
函数式编程中的函数这个术语不是指计算机中的函数,而是指数学中的函数,即自变量的映射。
也就是说一个函数的值仅决定于函数参数的值,不依赖其他状态。比如y=x*x函数计算x的平方根,
只要x的平方,不论什么时候调用,调用几次,值都是不变的
命令式编程
命令式编程是面向计算机硬件的抽象,有变量(对应着存储单元),赋值语句(获取,存储指令),
表达式(内存引用和算术运算)和控制语句(跳转指令),一句话,命令式程序就是一个冯诺依曼机的指令序列。
"""
# 把number =[2, -5, 9, -7, 2, 5, 4, -1, 0, -3, 8]中的正数的平均值
# 命令式编程
number =[2, -5, 9, -7, 2, 5, 4, -1, 0, -3, 8]
count = 0
sum = 0
for i in range(len(number)):
if number[i]>0:
count += 1
sum+=number[i]
print(sum,count)
if count>0:
average = sum/count
print(average)
# 函数式编程
from functools import reduce
number =[2, -5, 9, -7, 2, 5, 4, -1, 0, -3, 8]
positive = filter(lambda x: x>0, number)
listp=list(positive)
# print(reduce(lambda x,y:x+y,list(positive)))
average = reduce(lambda x,y:x+y,listp)/len(listp)
print(average)
# 导入整个模块
# import pizza
# pizza.make_pizza(16, 'pepperoni')
# pizza.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
# 导入特定的函数
# 若使用这种语法,调用函数时就无需使用句点。由于我们在import语句中显式地导入了函数make_pizza(),因此调用它时只需指定其名称。
# from pizza import make_pizza
#
# make_pizza(16, 'pepperoni')
# make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
# 使用as给函数指定别名
# from pizza import make_pizza as mp
# mp(16, 'pepperoni')
# mp(12, 'mushrooms', 'green peppers', 'extra cheese')
# 使用as给模块指定别名
# import pizza as p
# p.make_pizza(16, 'pepperoni')
# p.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
# 导入模块中的所有函数 *
from pizza import *
help(make_pizza)
# make_pizza(16, 'pepperoni')
# make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
pizza.py
def make_pizza(size, *toppings):
"""概述要制作的比萨"""
print("\nMaking a " + str(size) +
"-inch pizza with the following toppings:")
for topping in toppings:
print("- " + topping)
网友评论