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)