pycharm部分好用快捷鍵

變量名的定義

與之前學習過的語言有所不同的是，python中變量名的定義更加的簡潔
such as
整形。浮點型和字符串的定義

money=50
haha=13.14
gaga="hello"

字符串的定義依然是需要加上引號，也不需要寫；了

字符串拼接

在print輸出時使用“，”進行連接

type的使用方式

可以查看數據類型

也可以三方中轉

數據類型轉換

轉換成字符串可能比較方便，但是float轉換成int可能會損失精度

標識符命名規則

真好可以用中文 😄
其他沒啥要注意的，和其他語言一樣

基本運算符

ps：從來沒見過這么省事的編輯器，他居然會猜你想寫什么就給你寫好。它真的我哭死

字符串的多種定義方式

感覺python有一種獨特的瘋感，freedom！

字符串拼接

ps字符串之間才可以拼接

數字的話需要定義的時候是字符串類型

字符串格式化

name="黑馬程序員"
message="I am %s" % name
print(message)

這里必須是%和s，表示字符串站位
假如有很多個字符串的話

name="雪distance"
where="煙臺"
age=21
xiaoshu=13.14
print("我的名字是%s，我家住在%s,我的年齡是%d，我將會愛你%f"%(name,where,age,xiaoshu))

數字精度設置

不夠的會在前面補上空格，小數就可以約束后面的位數

快速字符串格式化

print(f"我的名字是{name}，我家住在{where},我的年齡是{age}，我將會愛你{xiaoshu}")

課后練習

name="傳智播客"
stock_code="003032"
stock_price=19.99
yinzi=1.2
growth=7
finalprice=stock_price*yinzi**growth
print(f"公司{name}，股票代碼{stock_code}，當前股價{stock_price}")
print("每日增長系數是：%.1f，經過%d天增長后，股價達到了：%.2f"%(yinzi,growth,finalprice))

上面的修改一下股票價格不需要加上引號
這里一個很智障的問題，沒搞明白數學公式咋寫

input的用法

print("告訴我你是誰")
name=input()
age=input()
print(f"{name}")
print("我知道了你是%s,年齡是%s" % (name,age))

input接受的是字符串形式的數據，故上面是%s，嘗試了一下%d會報錯
所以需要強制類型轉換

name=input("please tell me who are you")
name=int(name)
print(type(name))

小練習

user_name = input()
user_type=input()
print("您好：%s，您是尊貴的：%s用戶，歡迎您光臨。" % (user_name, user_type))

真假判斷

bool_1=True
bool_2=False
print(f"bool_1的內容是{bool_1}，類型是{type(bool_1)}")num1=10
num2=20
print(f"the final is {num1>=num2}")

需要注意的是，這里的True和False必須首字母大寫

if判斷語句

age=30
if age<=18:print("you are a kid")

python中沒有大括號的限制了，所以主要就是看前面縮進，別忘了加冒號
小練習

print("歡迎來到黑馬兒童游樂場，兒童免費，成人收費")
age=input("請輸入你的年齡")
age=int(age)
if age >= 18:print("您已成年，游玩需要補票10元。")
print("祝您游玩愉快")

if-else語句

if和else都需要加：

print("歡迎來到黑馬兒童游樂場，兒童免費，成人收費")
age=int(input("請輸入您的年齡"))
if age >= 18:print("您已成年，游玩需要補票10元。")
else:print("未成年！免費！")
print("祝您游玩愉快")

小練習

print("歡迎來到黑馬動物園")
age=int(input("請輸入您的身高（cm）"))
if age >= 120:print("您的身高超出120cm，游玩需要補票10元。")
else:print("免費游玩！")
print("祝您游玩愉快。")

if-else多條件判斷

elseif寫成elif了非常擺爛
if-elif-else


小練習

num=4
num1=int(input("請輸入第一次猜想的數字"))
if num1==num:print("猜對啦")
elif int(input("猜錯了在猜一次"))==num:print("猜對啦")
elif int(input("猜錯了，在猜最后一次"))==num:print("猜對了")
else:print("Sorry,猜錯了，我猜想的數字是%d" % num)

ps猜數字小游戲

# 猜數字小游戲
num=4
while True:num1 = int(input("請輸入一個數字"))if num1==num:print("你猜對啦")breakelif num1>num:print("你猜的數偏大了")else:print("你猜的數偏小了")

嵌套判斷語句

if int(input("你的身高是多少cm"))>120:print("不免費")print("但是VIP等級大于3，可以免費，請輸入VIP等級")if int(input("你的VIP級別是多少"))>3:print("免費！")else:print("不免費啦")
else:print("歡迎小朋友游玩")

這種只要題干里面描述清楚一般沒得問題

little練習

age=int(input("Enter your age:"))
time=int(input("Enter your enter time:"))
level=int(input("Enter your enter level:"))
if age>=18 and age<30:if time>2 or level>3:print("可以領取嗷")else:print("不能領取嗷")
else:print("不能領取嗷")

到是也能實現，但是和老師希望的可能不太一樣（老師希望可能一步一判斷），順便python的并且和或者竟然改成and和or了真好哇！

老師寫的代碼：

age=int(input("Enter your age:"))
time=int(input("Enter your enter time:"))
level=int(input("Enter your enter level:"))
if age>=18:print("你是成年人")if age<30:print("你的年齡達標")if time>2:print("你的入職時間達標")elif level>3:print("你的級別達標")else:print("入職時間或者級別不達標不能領取")else:print("你的年齡太大了嗷，不能領取")
else:print("未成年，不能領取嗷")

每一個if記得對應一個else

實戰訓練

代碼如下所示

import random
num=random.randint(1,10)
num1=int(input("請輸入數字"))
if num1==num:print("bingo")
elif num1>num:print("too big")num1=int(input("請第二次輸入數字"))if num1>num:print("too big")num1=int(input("請第三次輸入數字"))if num1>num:print("too big the num is %d"%num)elif num1<num:print("too small the num is %d"%num)else:print("bingo")elif num1<num:print("too small")num1 = int(input("請第三次輸入數字"))if num1 > num:print("too big the num is %d"%num)elif num1 < num:print("too small the num is %d"%num)else:print("bingo")else:print("bingo")
else:print("too small")num1 = int(input("請第二次輸入數字"))if num1 > num:print("too big")num1 = int(input("請第三次輸入數字"))if num1 > num:print("too big the num is %d"%num)elif num1 < num:print("too small the num is %d"%num)else:print("bingo")elif num1 < num:print("too small")num1 = int(input("請第三次輸入數字"))if num1 > num:print("too big the num is %d"%num)elif num1 < num:print("too small the num is %d"%num)else:print("bingo")else:print("bingo")

感覺是非常費勁的計算方式，假如使用上面的while循環或者for循環會比較簡單，這個就用來鍛煉邏輯
ps：三次猜數太難猜了，私心偷偷加了最后一次再猜不中就把數告訴我就完了，玩不過人工智能

while循環

假如表白100次就能成功！

n=10
while n>0:print("小美，我喜歡你")n-=1

怕給我電腦燒了，表白10次意思意思吧

little作業

n=1
sum1=0
while n<=100:sum1+=nn+=1# print(n)# print(sum1)
print(sum1)

這里出現101不重要，重要的是n=1和n=100之間就是100個數，假如從0開始，那么就要<100了

while循環猜數案例

帶生成隨機數版循環猜數案例

import random
num=random.randint(1,100)while True:num1=int(input("請輸入數字"))if num1==num:print("you are right")breakelif num1>num:print("too big")else:print("too small")

哈哈，也是猜了好多遍
老師沒有用break，使用的是修改flag，順便還記錄了一下你猜了多少次

import random
num=random.randint(1,100)
count=0
flag=True
while flag:count+=1num1=int(input("請輸入數字"))if num1==num:print("you are right")flag=Falseelif num1>num:print("too big")else:print("too small")
print(f"你一共猜了{count}次")

while嵌套循環

讓print語句輸出不換行

制表符\t

這個對于中文可能有點問題，用英文是沒有問題的

print("hello\tworld")
print("你好\tlihua")
print("itheima\tbest")

小練習

n=1
while n<=9:m=1while m<=n:print(f"{m}*{n}={m*n}\t",end='')m+=1n+=1print()

for循環

利用for循環遍歷字符串

name="hhagegege"
for x in name:print(x,end='')

小練習

count=0
for x in "itheima is a brand of itcast":if x=="a":count+=1
print(f"這個字符串里面一共有{count}個a")

暫時沒有區分大小寫

count=0
for x in "itheima is a brand of itcastAAA":if x=="a" or x=="A":count+=1
print(f"這個字符串里面一共有{count}個a")

這是區分大小寫的

for循環range語句

range里面一個數：到這個數有多少個

range兩個數：這兩個數字之前的所有數，不包含右端，包含左端
range三個數：左端，右端-1，加步長
上面三種語法代碼：

# 語法一
for x in range(10):print(x,end='')
print()
# 語法二
for x in range(1,10):print(x,end='')
print()
# 語法三
for x in range(1,10,2):print(x,end='')
print()

這種就是類似其他語言的for循環，也是實現執行幾遍的功能

small練習

num=int(input("Enter a number:"))
count=0
for x in range(1,num):if x%2==0:count+=1
print(f"1到{num}（不含100本身）有{count}個偶數")

for循環變量作用域

也就是我們之前學習的局部變量和全局變量

for i in range(5):print(i)
print(i)

這里實際上pycharm沒有和你計較，最好還是用比較規范的版本，進行全局定義

for循環的嵌套使用

想小美表白案例，一共一百天，每天10朵玫瑰

for i in range(1,101):print(f"the {i} day")for j in range(1,11):print(f"this is the {j} flower")print("xiaomei I love you")
print(f"the {i} day I succeed!")

我們之前使用while循環時，我們最后第幾天是i先++了，然后while判斷不執行，我們在輸出時還需要i-1現在for循環則是不管右端點的101，因此我們此時不需要進行i–的操作

練習for循環打印九九乘法表

for i in range(1,10):j=1for j in range(1,i+1):print(f"{j}*{i}={i*j}  ",end='')j=j+1print("\t")

下面老師寫的

for i in range(1,10):j=1for j in range(1,i+1):print(f"{j}*{i}={i*j}\t",end='')j=j+1print()

可以看出在間斷方面做得更加完美

continue和break的使用

continue：暫時跳過這一次（程序讀到continue就結束本次循環，直接到下一次）
break：結束循環，整個循環都結束

永遠不會執行語句2

永遠不會執行語句3，但是其他的都會被執行，這里注意一下語句4跟的誰

假如上面這個沒有break

for i in range(1,10):print("1")for j in range(1,10):print("2",end='')# breakprint("3",end='')print("4")

是這樣

循環綜合案例

import random
num=random.randint(1,100)
money=10000
for i in range(1,21):level=random.randint(1,10)if level>=5:if money>=1000:money=money-1000print(f"向員工{i}發放工資1000元，賬戶余額還剩{money}")else:print("工資發完了，下個月領取把")breakelse:print(f"員工{i}，績效分{level}，不發工資，下一位")

continue和break還是非常重要的

函數

提前寫好方便直接使用

str1="hahsdwibcwidb"
str2="hfbiurwb"
str3="cnefbvu"def mylen(str):count = 0for i in str:count += 1print(f"字符串的長度是{count}")length1=mylen(str1)
length2=mylen(str2)
length3=mylen(str3)

eg：統計字符串長度的函數，實際上python已經提供了一個方法len（）方法，也可直接調用

函數定義

簡單小函數

def sayhi():print("hi")
sayhi()

非常的人性！
我們調用要嚴格的遵循，調用在定義后面
小練習

def welcome():print("歡迎來到黑馬程序員")print("請出示您的72小時核酸檢測證明")
welcome()

老師寫的，差點忘記我們的老朋友\n

def welcome():print("歡迎來到黑馬程序員\n請出示您的72小時核酸檢測證明")# print("")
welcome()

函數的傳入參數

一個加法小函數

def add(a,b):result=a+bprint(f"{a}和{b}相加的結果是{result}")
add(1,2)

函數的傳入參數案例

def check(tem):if tem<=37.5:print(f"balabala……您是{tem}體溫正常，請進！")else:print(f"balabala……您是{tem}體溫異常，隔離去吧")check(36)
check(40)

函數返回值

我們假如使用return進行傳遞返回值的時候，需要拿一個變量來接

def add(a,b):return a+b
result=add(1,2)
print(result)

有返回值，只不過這里的返回值是None

def sayhi():print("hi")result=sayhi()
print(type(result))

def check(age):if age > 18:return "success"else:return None
result = check(18)
if not result:print("未成年禁止進入")

None=False
這里修改為True和False也是可以的，因為這樣返回類型就不為空了，就是返回的布爾類型

函數的說明文檔

主要就是在函數體前面記得備注，詳細一點，讓自己和他人都能看懂

函數的嵌套調用

def funb():print("funb")
def funa():print("funa")funb()print("func")
funa()

這個也是調用的函數需要提前定義完畢

變量在函數中的作用域

出了函數體在外面沒法用
全局變量在函數內外都是可以使用的
正常在函數里面修改全局變量的值是沒門的，但是在函數里面print一下能發現被修改了
引入global

在函數里面定義一下就是全局變量了

函數綜合案例

自個寫的感覺挺全面的

money=5000000
name=input("Enter your name: ")
def check():print("----------查詢余額-------------")print(f"{name}，你好，您的余額剩余{money}")
def cunkuan():print("----------存款-------------")money1=int(input("請輸入您要存多少錢"))print(f"{name}，你好，您的余額剩余{money+money1}")
def qukuan():print("----------取款-------------")money1 = int(input("請輸入您要取多少錢"))print(f"{name}，你好，您的余額剩余{money - money1}")while(True):print("-----------主菜單--------------")print(f"{name},hello,welcome,please choose")print("查詢余額\t[輸入1]\t")print("存款\t[輸入2]\t")print("取款\t[輸入3]\t")print("退出\t[輸入4]\t")choose=int(input("請輸入您的選擇"))if choose==1:check()elif choose==2:cunkuan()elif choose==3:qukuan()else:print("您已成功退出")break

唯一注意一下，這里的處理，對齊展示，一個不行那就多加幾個
ps老師原視頻指路，想看老師寫的代碼可以看
視頻鏈接P61

數據容器

但是猜測都是一個數據元素都是同類的里面

列表的定義

列表中可以存儲不同的數據類型
之前好像寫錯了，寫成只能一種類型了

name_list=['itheima','itcast','python']
print(name_list)
print(type(name_list))

假如里面放的不是一種數據類型，那么type依然是list類型

列表的下標索引

python支持正負進行取元素（雖然暫時不知道有啥用，但是很高級）
正向舉例

name_list=['tom','Lily','sam']
print(name_list[0])
print(name_list[1])
print(name_list[2])

負向舉例

name_list=['tom','Lily','sam']
print(name_list[-1])
print(name_list[-2])
print(name_list[-3])

嵌套索引同樣可以用下標
用二維數字數組表示，第一個內列表里面第一個個就是按照順序進行表示

name_list=[[9,8,6],[1,2,3]]
print(name_list[0][0])
print(name_list[0][2])
print(name_list[1][1])

唯一就是別忘了內部列表之間記得加，
還有下標是從0開始的，數對下標

列表的常用操作方法

也就是某個類給我們提供了一堆函數（方法）

name_list=["itcast","itheima","python"]
index=name_list.index("itheima")
print(f"itheima在列表中的下標索引是{index}")

輸入列表中的元素，查找元素在列表的那個位置

name_list=["itcast","itheima","python"]
name_list[0]="afteritcast"
print(name_list)

可以看到元素被修改成功了

name_list=[1,2,3]
name_list.insert(1,"insert")
print(name_list)

輸入的是什么數字，到最后就會插入到對應位置

name_list=[1,2,3]
name_list.append("insert")
print(name_list)

聽著，所謂追加元素，那肯定是在末尾（致敬殺手）

追加好多元素：extend

name_list=[1,2,3]
name_list.extend([4,5,6])
print(name_list)

追加的格式也是列表

name_list=[1,2,3]
name_list2=[4,5,6,7]
name_list.extend(name_list2)
print(name_list)

合并字符串變的輕輕松松

刪除第一種方法：del 列表【下標】

name_list=["itcast","itheima","python"]
del name_list[0]
print(f"列表刪除元素后，列表是{name_list}")

刪除第二種方法：列表.pop(下標)

name_list=["itcast","itheima","python"]
# del name_list[0]
element=name_list.pop(1)
print(f"列表刪除元素后，列表是{name_list},取出的元素是{element}")

瞎聯想一下，這個很想彈出棧內元素
del僅僅能完成刪除，但pop不僅可以刪除，還可以拿到這個元素

name_list=[1,2,3,4,4,6,2,7]
# del name_list[0]
name_list.remove(2)
print(f"列表刪除元素后，列表是{name_list}")

刪除第一個匹配的（希望趕快出一個全部匹配刪掉的，代碼題里面很常見）

列表全部清空

name_list=[1,2,3,4,4,6,2,7]
name_list.clear()
print(f"列表刪除元素后，列表是{name_list}")

統計某元素在列表內的數量

name_list=[1,2,3,4,4,6,2,7]
count=name_list.count(2)
print(f"列表2元素出現的次數為{count}")

列表增刪改查巴拉巴拉方法的總結（非常好）

查找某元素的下標
語法：列表.index（元素）
列表的插入元素
語法：列表.insert（下標，元素）
列表的追加元素
語法：列表.append（元素）
列表的大量追加元素
語法：列表.extend（其他列表）
列表的刪除元素
語法1：del 列表【下標】
語法2：列表.pop（下標）
列表刪除某元素在列表中的第一個匹配項
語法：列表.remove（元素）
清空整個列表
語法：列表.clear()
統計某元素在列表內的數量
語法：列表.count（元素）

列表課后練習

# 定義
student=[21,25,21,23,22,20]
# 追加31
student.append(31)
print(f"追加完數字31之后的列表{student}")
# 追加新列表
student.extend([29,33,30])
print(f"追加完新列表之后的列表{student}")
# 取出第一個元素
num=student.pop(0)
print(f"取出的第一個元素是{num}")
# 取出最后一個元素
num1=student.pop(-1)
print(f"取出的最后一個元素是{num1}")
# 查找元素
index=student.index(31)
print(f"元素下標是{index+1}列表是{student}")

通過這個例題我知道取負數下標有啥用了，假裝當我們不知道一共有幾個元素的時候，我們需要取元素，就可以直接取-1，就是最后一個元素

列表循環遍歷

student=["haha","gaga","QAQQAQ"]
len=len(student)
index=0
while index<len:element=student[index]print(f"取出來的元素是{element}")index+=1

student=["haha","gaga","QAQQAQ"]
for i in student:print(f"每次取出來的元素是{i}")

小練習

使用while循環

list=[1,2,3,4,5,6,7,8,9,10]
list1=[]
# 使用while循環
num=0
while num<len(list):if list[num]%2==0:list1.append(list.pop(num))num+=1
print(f"通過while循環，從列表取出偶數，組成的新列表{list1}")

使用for循環（偷偷給改成奇數了，反正偶數已經打印了一遍了）

list=[1,2,3,4,5,6,7,8,9,10]
list1=[]
# 使用for循環
num=0
for num in list:if num%2!=0:list1.append(num)num+=1
print(f"通過for循環，從列表中取出奇數，組成新列表{list1}")

while循環里面num類似于下標，但是for里面的num就類似于列表中的內容了

元組的定義和相關操作

元組相當于一個只讀的列表


元組的操作：比較全

# 定義元組
t1=(1,"hello",True)
print(f"t1的類型是{type(t1)},內容是{t1}")# 定義單個元素的元組
t2=("hello")
print(f"t1的類型是{type(t2)},內容是{t2}")
# 元組后面假如只有一個數據，數據后面要添加，不然就不是元組類型了，就是元素的類型了# 元組的嵌套
t3=((1,2,3),(4,5,6))
print(f"t1的類型是{type(t3)},內容是{t3}")# 下標索引取出內容，假設要取t3里面的5元素
num=t3[1][1]
print(f"取出的元素是{num}")# 元組的操作：index查找方法
t4=("haha","gaga","QAQQAQ")
index=t4.index("haha")
print(f"haha在元組里面的下標是{index}")# 元組的操作：count統計方法
t5=("haha","haha","haha","gaga","QAQQAQ")
count=t5.count("haha")
print(f"haha在元組里面出現的次數是{count}")# 元組的操作：len函數統計元組元素數量
length=len(t5)
print(f"t5元組的長度是{length}")# 元組的while遍歷，這里就是遍歷t5元組
num=0
while num<length:print(t5[num],end='')num+=1
print("")
# 元組的for遍歷
for element in t5:print(element,end='')

元組里面的元素不能修改
but元組里面的列表可以修改

t9=(1,2,["haha","gaga","QAQQAQ"])
print(t9)
t9[2][0]="hahaha"
t9[2][1]="gagaga"
print(t9)

現在不知道為什么這么設定，功能有點雞肋，但是它這么做一定有他的道理！

小練習

Jay=('周杰倫',11,['football','music'])
# 查詢年齡在的下標
index=Jay.index(11)
print(f"年齡所在的下標是{index}")
# 查詢學生姓名
str=Jay[0]
print(f"學生姓名是{str}")
# 刪除學生愛好中的football
Jay[2].remove("football")
print(f"刪除愛好之后元組是{Jay}")
# 增加愛好：coding（每日催眠，我愛編程我愛編程）
Jay[2].append("coding")
print(f"添加愛好之后元組是{Jay}")

字符串的定義和操作

這里的字符串就類似于我們之前學習過的列表和元組了，就是存放大量字符的地方
字符串也是一個不可以修改的數據容器


類似查找替換

分割字符串，到不同的列表中，也就是進行切分

簡潔來說就是掐頭去尾，去掉前后沒有意義的東西

這個不知道是我使用有問題還是咋的，很雞肋
空格就只能去兩頭空格
數字去完了之后假如有空格還是有

字符串操作匯總

str="haha and gaga or QAQQAQ"
# 通過下標取索引
value=str[1]
value1=str[-5]
print(value)
print(value1)
# 假如我們要修改字符串里面的數據，就只能新增一個字符串# index方法
value=str.index("and")
print(f"在字符串中and的起始下標是{value}")# replace方法,老的字符串并不會修改，需要一個新的字符串取接它
str1=str.replace("haha","哈哈")
print(f"替換完的新字符串是{str1}")# split方法
str2=str.split("a")
print(f"切割完的新字符串是{str2}")
str3=str.split(" ")
print(f"切割完的新字符串是{str3}")# strip方法
str3="12  haha and gaga or QAQQAQ  12"
print(str3.strip())
print(str3.strip("12"))# 統計字符串中某字符串的出現次數，count
count=str.count("ga")
print(f"ga這個字符串出現的次數是{count}")# 統計字符串的長度，len（）
length= len(str)
print(f"str字符串的長度是{length}")

while循環和for循環

str="花花，你是一只小豬"
# while字符串循環
index=0
while index<len(str):print(str[index])index+=1
print("")
# for字符串循環
for i in str:print(i)

字符串練習

str="itheima itcast boxuegu"
# 統計一共有多少個“it”字符
count=str.count("it")
print(f"一共有{count}個“it”字符")
# 將字符串空格換成|
str1=str.replace(" ","|")
print(f"換完之后是{str1}")
# 按照|進行字符串分割，得到列表
str2=str1.split("|")
print(f"分割完之后是{str2}")

數據容器（序列）的切片

步長2，中間隔一個
步長3，中間隔兩個
序列切片也是不會影響序列本身，而是整個新的序列

# 對list進行切片，從1開始，4結束，步長1
list=[1,2,3,4,5,6,7,8,9,10]
# 開始，結束，步長(步長可以省略不寫list[1:4])
result=list[1:4:1]
print(f"結果是{result}")# 對tuple進行切片，從頭開始，到最后結束，步長1
tuple=(1,2,3,4,5,6,7,8,9,10)
# 可以這么表示，是開頭和結尾的話，步長還是1就都可以省略了
result1=tuple[0:len(tuple):1]
# 省略之后是這樣
# result1=tuple[:]
print(f"結果是{result1}")# 對str進行切片，從頭開始，到最后結束，步長2
str="12345678910"
result2=str[::2]
print(f"結果是{result2}")# 對str進行切片，從頭開始，到最后結束，步長-1
str1="12345"
result3=str1[::-1]
print(f"結果是{result3}")# 對列表進行切片，從3開始，到1結束(不包含它本身)，步長-1
list1=[1,2,3,4,5,6,7]
result4=list1[3:1:-1]
print(f"結果是{result4}")# 對元組進行切片，從頭開始，到尾結束，步長-2
tuple1=(1,2,3,4,5,6,7)
result5=tuple1[::-2]
print(f"結果是{result5}")

元組，字符串，列表都是可以劃分的都是
【開始：結束：步長】需要一個東西來接輸出結果

# 這一步主要是得到這個倒序的序列，我不想自己敲
str="學Python，來黑馬程序員，月薪過萬"
str1=str[::-1]
# 得到正序序列
str2=str1[::-1]
str3=str2.split("，")
str4=str3[1]
str5=str4.replace("來"," ")
str6=str5.strip(" ")
print(str6)

寫的有點麻煩感覺

老師寫的：

# 這一步主要是得到這個倒序的序列，我不想自己敲
str="學Python，來黑馬程序員，月薪過萬"
str1=str[::-1]
# 倒序字符串，然后切片
str2=str1[::-1][9:14]
print(str2)
# 切片，然后倒序
str3=str1[5:10][::-1]
print(str3)
# split分割，replace替換來為空，倒序字符串
str4=str1.split("，")[1][::-1].replace("來","")
print(str4)

被python一長串爽到了
不用加中間變量

集合的定義和操作

集合里面沒有重復元素，并且也是無序的

集合的操作

set1={"haha","gaga","QAQQAQ",}
my_set=set()
# 添加新元素
set1.add("huhu")
print(f"set添加元素之后結果是{set1}")
# 移除元素
set1.remove("haha")
print(f"set移除元素之后結果是{set1}")
# 隨機取出一個元素
element=set1.pop()
print(f"set隨機取出的元素是{element}，還剩下集合{set1}")
# 清空集合
set1.clear()
print(f"set清空元素之后結果是{set1}")
# 取2個集合的差集
set2={1,2,3}
set3={2,3,4,5}
set4=set2.difference(set3)
print(set4)
# 消除2個集合的差集
set2.difference_update(set3)
print(set2)
# 2個集合合并為一個
set1={1,2,3}
set2={1,5,6}
set3=set1.union(set2)
print(set3)
# 統計集合元素數量len()
set1={1,2,3,4,5}
print(f"元素數量有{len(set1)}")
# 集合的遍歷（不能用while循環，不支持下標索引）
for element in set1:print(f"元素有{element}")

集合課后練習

my_list=['黑馬程序員','haha','黑馬程序員','haha','gaga','gaga','huhu','huhu','best']
set1=set()
for element in my_list:set1.add(element)
print(set1)

它自動得出來就是不重復的了

字典定義

類似于我們平常使用的字典


定義字典也是大括號（和集合一樣）
但是里面是定義鍵值對



外層key是學生姓名，內層key是考試科目

# 字典定義
dict11={"xiaoming":99,"Jay":88,"lihua":77}
# 定義空字典
dict1={}
dict2=dict()
print(f"字典一的內容是{dict11}，類型是{type(dict1)}")
print(f"字典一的內容是{dict1}，類型是{type(dict1)}")
print(f"字典一的內容是{dict2}，類型是{type(dict2)}")
# 定義重復key的字典,新的數會把老的數字覆蓋掉
dict3={"xiaoming":99,"Jay":88,"lihua":77,"xiaoming":53}
print(f"字典一的內容是{dict3}")
# 從字典中基于key獲取value
dict11={"xiaoming":99,"Jay":88,"lihua":77}
score=dict11["xiaoming"]
print(f"小明的分數是{score}")
# 定義嵌套字典
student_score_dict={"xiaoming":{"語文":77,"數學":66,"英語":33},"Jay":{"語文":88,"數學":86,"英語":55},"lihua":{"語文":99,"數學":96,"英語":66}
}
print(f"學生的考試成績是{student_score_dict}")
# 從嵌套字典中獲取數據
score=student_score_dict["Jay"]["語文"]
print(f"Jay的語文成績是{score}")
score1=student_score_dict["lihua"]["英語"]
print(f"lihua的英語成績是{score}")

字典的常用操作

新增元素

更新元素

dict11={"xiaoming":99,"Jay":88,"lihua":77}
# 新增元素
dict11["lihaha"]=66
print(f"新增之后的字典{dict11}")
# 更新元素
dict11["Jay"]=69
print(f"更新之后的字典{dict11}")
# 刪除元素
score=dict11.pop("xiaoming")
print(f"刪除的元素是{score}，刪除之后的字典是{dict11}")# 清空元素
dict11.clear()
print(f"清空之后的字典{dict11}")# 獲取全部的key
dict11={"xiaoming":99,"Jay":88,"lihua":77}
key=dict11.keys()
print(f"字典全部的keys{key}")
# 遍歷字典,兩種方法
for key,value in dict11.items():print(f"字典中的key是{key}")print(f"字典中的value是{value}")
for key in dict11.keys():print(f"字典中的key是{key}")print(f"字典中的value是{dict11[key]}")
# 統計字典內的元素數量
length=len(dict11.keys())
print(f"元素數量{length}")

字典課后練習

staff_information={"王力宏":{"部門":"科技部","工資":3000,"級別":1},"周杰倫":{"部門":"市場部","工資":5000,"級別":2},"林俊杰":{"部門":"市場部","工資":7000,"級別":3},"張學友":{"部門":"科技部","工資":4000,"級別":1},"劉德華":{"部門":"市場部","工資":6000,"級別":2}
}
print(f"全體員工的當前信息{staff_information}")for name in staff_information:if staff_information[name]["級別"] == 1:# 獲取到員工的信息字典！！！employee_information=staff_information[name]# 修改員工信息employee_information["工資"]+=1000employee_information["級別"]=2# 將嵌套字典的東西更新回去！！！staff_information[name]=employee_information
print(f"全體員工的當前信息{staff_information}")

這個案例很好，主要練習了嵌套的類型，很有借鑒意義

5類數據容器的總結（五顆星）

數據容器的通用操作

max,min,len


最大的收獲就是又學了一個快捷鍵：
shift+Alt+鼠標拖動
可以批量選擇，然后進行修改

my_list = [1,2,3,4,5,6,7,8,9]
my_tuple = (1,2,3,4,5,6,7,8,9)
my_string = 'hello world'
my_set = {1,2,3,4,5,6,7,8,9}
my_dict = {1,2,3,4,5,6,7,8,9}print(f"列表 元素個數有{len(my_list)}")
print(f"元組 元素個數有{len(my_tuple)}")
print(f"字符串 元素個數有 {len(my_string)}")
print(f"集合 元素個數有{len(my_set)}")
print(f"字典 元素個數有{len(my_dict)}")print(f"列表 最大的元素是{max(my_list)}")
print(f"元組 最大的元素是{max(my_tuple)}")
print(f"字符串最大的元素是{max(my_string)}")
print(f"集合 最大的元素是{max(my_set)}")
print(f"字典 最大的元素是{max(my_dict)}")print(f"列表 最小的元素是{min(my_list)}")
print(f"元組 最小的元素是{min(my_tuple)}")
print(f"字符串最小的元素是{min(my_string)}")
print(f"集合 最小的元素是{min(my_set)}")
print(f"字典 最小的元素是{min(my_dict)}")

整整齊齊





轉換不了字典：因為字典是鍵值對

print(f"列表對象的排序結果：{sorted(my_list)}")
print(f"元組對象的排序結果：{sorted(my_tuple)}")
print(f"字符串對象的排序結果：{sorted(my_string)}")
print(f"集合對象的排序結果：{sorted(my_set)}")
print(f"字典對象的排序結果：{sorted(my_dict)}")

本來亂七八槽的就變得有序了，都變成了列表對象

print(f"列表對象的排序結果：{sorted(my_list,reverse=True)}")
print(f"元組對象的排序結果：{sorted(my_tuple,reverse=True)}")
print(f"字符串對象的排序結果：{sorted(my_string,reverse=True)}")
print(f"集合對象的排序結果：{sorted(my_set,reverse=True)}")
print(f"字典對象的排序結果：{sorted(my_dict,reverse=True)}")

全倒過來了

字符串大小比較

按照ASCII進行大小比較的65A，97a
小寫a比較大

從前向后比較


不知道是我電腦的問題還是咋，感覺在這里面敲有點卡，換個文章繼續干