1.變量启绰、2.運(yùn)算符、3.分支與循環(huán)簸淀、4.列表與元組瓶蝴、5.字符串處理、6.字典與集合 租幕、7.變量值與內(nèi)存舷手、8.函數(shù)

1.變量

# 單行注解使用井號(hào)
"""
三個(gè)雙引號(hào)
或
三個(gè)單引號(hào)
為多行注釋
"""
'''
三個(gè)雙引號(hào)
或
三個(gè)單引號(hào)
為多行注釋
'''
studentid='a123'
studentname='tom'
print("studentid:",studentid," studentname:",studentname)

price=50.5
weight=4.5
sum=price*weight
print("總價(jià)格為",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相當(dāng)于 java中的數(shù)組
print(type(a6))
# 元組屬于不可變列表 此數(shù)據(jù)類型java中無對應(yīng)類型
print(type(a7))
# 字典相當(dāng)于java中的map集合
print(type(a8))
# 集合相當(dāng)于java中的集合
print(type(a9))

# list與set區(qū)別
# 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)))


# 練習(xí)
ap = input("apple price")
aw = input("apple weight")
print("總價(jià)為"+str(int(ap)*int(aw)))

# c風(fēng)格輸出 %類似java中的反斜杠 為轉(zhuǎn)義字符 與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 字符串升級(jí)寫法
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.運(yùn)算符

a1=True
a2=False
a3=0
a4=1
a5=2
"""
與java不同的運(yùn)算符  
1除法自動(dòng)得小數(shù) 想實(shí)現(xiàn)取整數(shù) 需要使用 //
2有乘方(冪) 符號(hào)為 **
"""

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")

# 邏輯運(yùn)算符
'''
邏輯運(yùn)算符與java不同處
1. 取反在python中使用not 在java中使用 劲绪！
2. 當(dāng)為真假時(shí)為短路運(yùn)算
3. 當(dāng)為數(shù)字時(shí)
 # 判斷變量是否為0男窟， 是0則為False，非0判斷為True贾富，
 # and中含0歉眷，返回0； 均為非0時(shí)颤枪，返回后一個(gè)值汗捡， 
2 and 0   # 返回0
2 and 1   # 返回1
1 and 2   # 返回2
# or中， 至少有一個(gè)非0時(shí)畏纲，返回第一個(gè)非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.分支與循環(huán)

a1=10
a2=20

"""
if條件與java使用方法一直扇住，語法關(guān)鍵詞稍有不同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)

"""
循環(huán) 與java邏輯一致
yujava不同點(diǎn) 當(dāng)沒有表達(dá)式時(shí) java {} python pass

"""
# 1+2.....+100
b1=0
bsum1=0
while b1<=100:
    bsum1=bsum1+b1
    b1=b1+1
print(bsum1)

# 大于1000時(shí)終止
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 循環(huán)  與Java不同 類似java中的 foreach語句
for（in）

"""
# 遍歷字符串
for n in  "hello how are you":
    print(n)
# 遍歷數(shù)字 利用range(m,n)函數(shù) 其實(shí)m 共打印 n-m個(gè)  最大值為 n-1
for n in range(1,5):
    print(n)

"""
9*9 算法表
1*1=1              k1=1  t1=1               規(guī)律： 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 打印 自動(dòng)換行 如果不想換行 使用 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()

"""
隨機(jī)生成數(shù)與java 不同  python隨機(jī)生成的為左閉右閉  java 生成為隨機(jī)數(shù) 左閉右開
"""
import random
#　random.randint(a, b) ，返回 [a, b] 之間的整數(shù)盗胀，包含 a 和 b

k=1
while k<100:
    n2 = random.randint(1, 10)
    print(n2,end=",")
    k=k+1

4列表與元組

"""
列表 list
與java中的ArrayList類似
寫法與java數(shù)組類似
"""
al=[1,2,3,4,5,6,7,8]
# 遍歷list
for n in al:
    print(n)
#  字符串轉(zhuǎn) list
a2="hello how are you"
print(list(a2))
# list 轉(zhuǎn)字符串
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插入
# 以上為使用原地址進(jìn)行拼接  -----原地操作
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))#刪除第一個(gè)
print(b3)
print(b3.clear())
print(b3)


b4=[1,2,3,4,5,6,7,8,1]
print(b4)
del b4[1]
print(b4)
# 列表訪問技術(shù) count計(jì)數(shù)   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()) #默認(rèn)升序
print(b5)
# 降序三種方法
# 方法一
# b5.sort(reverse=True)
# print(b5)
# 方法二
# b5.sort()
# # b5.reverse()
# print(b5)
# 方法三
# b5.sort()
# print(list(reversed(b5)))
# 返回可迭代的zip對象 用法后續(xù)拓展

# 返回帶下表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)等價(jià)
for k in range(len(b8)):
# for k in range(0,len(b8)):
    print(b8[k],end="")
print()
# 遍歷枚舉類型多個(gè)參數(shù)值 第一個(gè)為下表 第二個(gè)參數(shù)為值
for i,ele in enumerate(b8):
    print(f"{i} : {ele}")
'''
列表推導(dǎo)式 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=[]
相當(dāng)于 
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的重新放到新數(shù)組里
'''
aList = [-1,-4,6,7.5,-2.3,9,-11]
list4 =[ n for n in aList if n>0 ]
 相當(dāng)于 
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)

'''
解決冒泡排序問題
實(shí)現(xiàn)從小到大排序
'''
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無負(fù)值 python可以設(shè)置負(fù)值從右向左
python中的有序序列都支持切片艘蹋，如字符串，元組,列表票灰。
'''
colors = ["red", "blue", "green"]
print(colors[-1])
'''
li[start : end : step]
默認(rèn) step為1
如果不寫前或尾 自動(dòng)從前到尾
如果 右超出界限 自動(dòng)到當(dāng)前最大值  
方向
step = 1
---------------------->

 -4   -3   -2   -1
["A", "B", "C", "D"]
  0    1    2    3
  step=-1
<--------------------
  
  [0,2]
  從0開始 共2-0個(gè)元素
'''
li = ["A", "B", "C", "D"]
t=li[0:3]       # ["A","B","C"]        #起點(diǎn)的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],設(shè)定步長為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"]   #正向切全部

# 使用切片來原地修改列表內(nèi)容
alist6=[1,2,3,4,5,6]
# 后增加 7,8,9
alist6[len(alist6):]=[7,8,9]
print(alist6)
# 將前三個(gè)換為8，9
alist6[:3]=[8,9]
print(alist6)
# 刪除前三個(gè)
# 方法一
alist6[:3]=[]
print(alist6)
#方法二
del alist6[:3]
print(alist6)

#刪除偶數(shù)位的元素
alist7=[1,2,3,4,5,6,7,8,9,10]
del alist7[1::2]
print(alist7)

'''
淺層復(fù)制與深層復(fù)制問題后續(xù)拓展
https://baijiahao.baidu.com/s?id=1597371058109891101&wfr=spider&for=pc
'''

'''
元組 tuple 元組屬于不可變序列（元素集合）屈糊，一旦創(chuàng)建的榛，
用任何方法都不可以修改其元素。從形式上逻锐，元組的所有元素放在一對 圓括 ()號(hào)中夫晌，
元素之間用逗號(hào)分隔。
'''
c1=(1,2,3,4,5,6)
print(tuple("hello"))  #把字符串轉(zhuǎn)換為元組
print(tuple(list("hello"))) #把列表轉(zhuǎn)換為元組

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結(jié)尾

#find找不到-1 index找不到報(bào)錯(cuò)
s4 = 'chhengt'
print(s4.find('h'))  #### 通過元素找索引找到第一個(gè)就返回（可切片）
print(s4.find('b'))  #### 找不到返回 -1
# print(s4.index('b'))   #### 找不到會(huì)報(bào)錯(cuò)

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())    #### 默認(rèn)以空格分割
print(s62.split(';'))    #### 以指定字符分割
print(s62.split(';', 1)) #### 指定分割多少個(gè)


#列表轉(zhuǎn)字符串  join

li = ['aa', 'ddj', 'kk']
print("".join(li))
print(",".join(li))

str=""
for n in li:
    str=str+n;
print(str)

#### 字符串.isalnum()    所有字符都是數(shù)字或者字母昧诱，為真返回 Ture晓淀，否則返回 False。
#### 字符串.isalpha()     所有字符都是字母盏档，為真返回 Ture凶掰，否則返回 False。
#### 字符串.isdigit()     所有字符都是數(shù)字蜈亩，為真返回 Ture懦窘，否則返回 False。
#### 字符串.islower()    所有字符都是小寫稚配，為真返回 Ture畅涂，否則返回 False。
#### 字符串.isupper()    所有字符都是大寫道川，為真返回 Ture午衰，否則返回 False。
#### 字符串.istitle()            所有單詞都是首字母大寫冒萄，為真返回 Ture臊岸，否則返回 False。
#### 字符串.isspace()    所有字符都是空白字符宦言，為真返回 Ture扇单，否則返回 False。

#### is 系列
name = 'taibai123'
print(name.isalnum()) # True   #### 字符串由數(shù)字或字母組成時(shí)返回真
print(name.isalpha()) # False  #### 字符只由字母組成時(shí)返回真
print(name.isdigit()) # False  #### 字符只由數(shù)字組成時(shí)返回真

#### count 計(jì)算字符串中某個(gè)字符出現(xiàn)的次數(shù)  ***
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() 將字符串居中可以設(shè)置總長度鸦采，可以設(shè)置填充物 * 默認(rèn)空格填充
s = 'chenziwu'
s2 = s.center(50)
print(s2)
s2 = s.center(50, '*')
print(s2)

# title 非字母隔開的每個(gè)單詞的首字母大寫 *
s = 'chen wuang4fhsa￥fh宾巍。f'
#### title  非字母隔開的每個(gè)單詞的首字母大寫 *
s4 = s.title()
print(s4)


# 字符串是不可變變量，不支持直接通過下標(biāo)修改
msg = 'abcdefg'
# msg[2] = 'z' //不可通過下表修改

msg = msg[:2] + 'z' + msg[3:]

print(msg)

6.字典與集合

"""
字典類型
相當(dāng)于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 轉(zhuǎn) dict
print(dict(zip(keys, values)))
print(type(dict(zip(keys, values))))
print(list(zip(keys, values)))
# list->tuple 轉(zhuǎn) dict
print(dict(list(zip(keys, values))))
#特殊寫法 轉(zhuǎn) 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方法獲取指定鍵對應(yīng)的值顶霞，并且可以在鍵不存在的時(shí)候返回指定值。
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:                       #不加特殊說明选浑，默認(rèn)輸出鍵
    print(key)
print(aDict.keys())
print(aDict.values())

# 使用字典對象的setdefault()方法返回指定“鍵”對應(yīng)的“值”，如果字典中不存在該“鍵”玄叠，就添加一個(gè)新元素并設(shè)置該“鍵”對應(yīng)的“值”
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方法將另一個(gè)字典的鍵古徒、值對添加到當(dāng)前字典對象
aDict.update({'a': 'a', 'b': 'b'})
print(aDict)
'''
字典刪除
使用del刪除整個(gè)字典，或者字典中的指定元素
使用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添加元素極其順序 目前加入順序與數(shù)據(jù)結(jié)構(gòu)順序一致
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 }
相當(dāng)于
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)

# 練習(xí)：同一個(gè)字母但不同大小寫的值合并起來了读恃。
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相當(dāng)于java中的collection 下的無序集合 每次輸出都可能不同隧膘！
# 自動(dòng)去除重復(fù) 無序
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（無當(dāng)前空間未定義再次調(diào)用會(huì)報(bào)錯(cuò)） 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()來使一個(gè)集合加入到當(dāng)前集合中
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
#隨機(jī)選擇1~500之間的數(shù)
print(random.choice(range(500)))
# 快速生成 100個(gè)1~500的隨機(jī)數(shù)
listRandom = [random.choice(range(500)) for i in range(100)]
print(listRandom)
# 將里面的單一元素進(jìn)行提取
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)


# 集合推導(dǎo)
s = {x.strip() for x in ('  he  ', 'she    ', '    I')}
print(s)


# 統(tǒng)計(jì)單詞出現(xiàn)的頻次
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,'出現(xiàn)次數(shù)：',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))


# 奧運(yùn)會(huì)足球分組
# # 已知有十六支男子足球隊(duì)參加2008 北京奧運(yùn)會(huì)。寫一個(gè)程序狐粱，把這16 支球隊(duì)隨機(jī)分為4 個(gè)組舀寓。采用List集合和隨機(jī)數(shù)
# #
# # 2008 北京奧運(yùn)會(huì)男足參賽國家：
# #
# # 科特迪瓦，阿根廷肌蜻，澳大利亞互墓，塞爾維亞，荷蘭蒋搜，尼日利亞篡撵，日本，美國豆挽，中國育谬，新西蘭，巴西帮哈，比利時(shí)膛檀，韓國，喀麥隆娘侍，洪都拉斯咖刃，意大利
# #
# # 提示：分配一個(gè)，刪除一個(gè)

# // map憾筏，保存最終分組結(jié)果
# // key保存的是第幾組嚎杨，value是該組對應(yīng)的國家集合
import random
groupNum2Countrys = {}

strCountrys = "科特迪瓦，阿根廷氧腰，澳大利亞枫浙，塞爾維亞刨肃，荷蘭，尼日利亞箩帚，日本真友，美國，中國膏潮，新西蘭锻狗，巴西，比利時(shí)焕参，韓國，喀麥隆油额，洪都拉斯叠纷，意大利";
countryList = strCountrys.split("，")

for i in range(4):
    lstGroup = []
    # // 分第1組
    # // 隨機(jī)從集合中選出一個(gè)國家潦嘶，放到第1組里涩嚣；然后將這個(gè)選出的國家，從原來集合中干掉（刪除）
    # // 重復(fù)以上步驟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.變量值與內(nèi)存

'''
== 運(yùn)算符比較兩個(gè)對象的值（對象中保存的數(shù)據(jù)）掂僵，而 is 比較對象的引用（標(biāo)識(shí)）航厚。 通常，我們關(guān)注的是值锰蓬，而不是標(biāo)識(shí)幔睬，因此 Python 代碼中 == 出現(xiàn)的頻率比 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地址不同

'''
傳參數(shù) 可以用貼標(biāo)簽來理解
'''

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)
'''
不可變類型芹扭，內(nèi)存中的數(shù)據(jù)不允許被修改：
數(shù)字類型 int, bool, float, complex, long(2.x)
字符串 str
元組 tuple
可變類型麻顶，內(nèi)存中的數(shù)據(jù)可以被修改：
列表 list
字典 dict
自定義類型（class定義的類型，后面講到）

此處可以類比java中在堆內(nèi)存中 被修改 地址不變舱卡，而棧內(nèi)存中 數(shù)據(jù)不可修改 當(dāng)發(fā)生變化地址改變
'''

8.函數(shù)

#定義函數(shù)
def  chengji(a,b):
    return a*b

print(chengji(2,3))

# 函數(shù)的好處 重用
#替換第三個(gè)元素
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))


#函數(shù)調(diào)用 特殊用法
'''
1.調(diào)用順序可調(diào) 使用參數(shù)賦值
2.使用默認(rèn)參數(shù)可不賦值
3.不定長參數(shù)
   3.1未命名 *abc    變量為tuple元組
   3.2命名   **abc    dict 字典

'''
def f(name,age):
    print(name+":"+str(age))
f("tom",19)
f(age=18,name="jerry")
#默認(rèn)參數(shù)
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):報(bào)錯(cuò)  * 在前   **在后
     print('Name:%s'%name)
     print('args:',args)
     print('kwargs:',kwargs)
#傳值時(shí)注意 后面的nickname內(nèi)部不要與name重名
print_info("tom",1,2,3,4,nickname="tom",key="asdf")

#將set 與dict 解析 分別使用*  與**
print_info("jerry",*{1,23,4,5},**{"nickname":"aaa"})


# 函數(shù)的返回值
'''
return多個(gè)對象辅肾，解釋器會(huì)把這多個(gè)對象組裝成一個(gè)元組作為一個(gè)整體結(jié)果輸出
這里與java不同java不能返回多個(gè)對象

'''
def f():
    return 1,2
print(f())

'''
高階函數(shù)
接受一個(gè)或多個(gè)函數(shù)作為輸入 輸出一個(gè)函數(shù)
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）以及函數(shù)（def矫钓、lambda）才會(huì)引入新的作用域，
其它的代碼塊（如if舍杜、try新娜、for等）是不會(huì)引入新的作用域的
"""
if(1==1):
    x=10
print(x)



def test():
     x = 2
print(x) # NameError: name 'x2' is not defined


"""
 # 錯(cuò)誤的原因在于print(x)時(shí),解釋器會(huì)在局部作用域找,會(huì)找到x=5(函數(shù)已經(jīng)加載到內(nèi)存),但x使用在聲明前了,所以報(bào)錯(cuò):
 # local variable 'x' referenced before assignment.如何證明找到了x=5呢?簡單:注釋掉x=5,x=6
 # 報(bào)錯(cuò)為: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)

'''
遞歸函數(shù)
'''
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可以為零，數(shù)列有［0］

    if n <= 1:
        return n
    return(fibo_new(n-1) + fibo_new(n-2))

print(fibo_new(10))

# 匿名函數(shù)
# 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],返回一個(gè)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()函數(shù)接收兩個(gè)參數(shù)蝴簇，一個(gè)是函數(shù)杯活，一個(gè)是Iterable，map將傳入的函數(shù)依次作用到序列的每個(gè)元素熬词，并把結(jié)果作為新的Iterator返回
print(list(map(lambda x:x**2 ,li)))

# reduce把一個(gè)函數(shù)作用在一個(gè)序列[x1, x2, x3, ...]上旁钧，這個(gè)函數(shù)必須接收兩個(gè)參數(shù)吸重，reduce把結(jié)果繼續(xù)和序列的下一個(gè)元素做累積計(jì)算，其效果就是：
# 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()也接收一個(gè)函數(shù)和一個(gè)序列歪今。和map()不同的是嚎幸，filter()把傳入的函數(shù)依次作用于每個(gè)元素，然后根據(jù)返回值是True還是False決定保留還是丟棄該元素寄猩。
# 在一個(gè)list中嫉晶，刪掉偶數(shù)，只保留奇數(shù)
li = [1, 2, 4, 5, 6, 9, 10, 15]
print(list(filter(lambda x:True if x%2==1 else False ,li)))

# 回?cái)?shù)是指從左向右讀和從右向左讀都是一樣的數(shù)田篇，例如12321替废，909。請利用filter()篩選出回?cái)?shù)
#方法一
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函數(shù) 接收一個(gè)key函數(shù)來實(shí)現(xiàn)對可迭代對象進(jìn)行自定義的排序
# 可迭代對象：主要與列表泊柬，字符串椎镣，元祖，集合和字典
# key：接受一個(gè)函數(shù)兽赁，根據(jù)此函數(shù)返回的結(jié)果状答，進(jìn)行排序
# reverse：排序方向，默認(rèn)為從小到大刀崖，reverse=True為逆向

# 對列表按照絕對值進(jìn)行排序
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()))
# 假設(shè)我們用一組tuple表示學(xué)生名字和成績：
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))


"""
 函數(shù)式編程
 函數(shù)式編程中的函數(shù)這個(gè)術(shù)語不是指計(jì)算機(jī)中的函數(shù)惊科，而是指數(shù)學(xué)中的函數(shù)，即自變量的映射亮钦。
 也就是說一個(gè)函數(shù)的值僅決定于函數(shù)參數(shù)的值馆截，不依賴其他狀態(tài)。比如y=x*x函數(shù)計(jì)算x的平方根或悲，
 只要x的平方孙咪，不論什么時(shí)候調(diào)用，調(diào)用幾次巡语，值都是不變的
 命令式編程
 命令式編程是面向計(jì)算機(jī)硬件的抽象翎蹈，有變量（對應(yīng)著存儲(chǔ)單元），賦值語句（獲取男公，存儲(chǔ)指令）荤堪，
 表達(dá)式（內(nèi)存引用和算術(shù)運(yùn)算）和控制語句（跳轉(zhuǎn)指令），一句話枢赔，命令式程序就是一個(gè)馮諾依曼機(jī)的指令序列澄阳。
"""
# 把number =[2, -5, 9, -7, 2, 5, 4, -1, 0, -3, 8]中的正數(shù)的平均值
# 命令式編程
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)
# 函數(shù)式編程
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)
# 導(dǎo)入整個(gè)模塊
# import pizza
# pizza.make_pizza(16, 'pepperoni')
# pizza.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
# 導(dǎo)入特定的函數(shù)
# 若使用這種語法，調(diào)用函數(shù)時(shí)就無需使用句點(diǎn)踏拜。由于我們在import語句中顯式地導(dǎo)入了函數(shù)make_pizza()碎赢，因此調(diào)用它時(shí)只需指定其名稱。
# from pizza import make_pizza
#
# make_pizza(16, 'pepperoni')
# make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
# 使用as給函數(shù)指定別名
# 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')
# 導(dǎo)入模塊中的所有函數(shù) *
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)