元組（tuple）

1、元組與列表的區別

列表是可變的，元組是不可變的。

列表的可變指的是列表可以新增元素，可以刪除元素，

元組的不可變指的是元組不可以增加新的元素，也不可以刪除已有的元素

2、元組的組成元素

元組裡面的元素可以是字串，也可以是數字， 也可以是元組本身，也可以是列表

3、'count'與'index'

tuple.'count'：檢視元組的

tuple.'index'：

4、注意事項

當元組裡面只有一個元素時，一定在元素後面加逗號

5、程式設計實訓

1）建立元組

#建立tuple1元組
tuple1=(1,'a',2,1,['Go','Python',(1,2,3,'4')])
#輸出在tuple1中元素[1]的數量
print(tuple1.count(1))
#輸出在tuple1中元素[2]的索引
print(tuple1.index(2))

#執行結果
2
2
 

2）獲取元組裡面的元素

#獲取元組裡面的元素[Go]
print(tuple1[4][0])
#獲取元組裡面的元素['4']
print(tuple1[4][2][3])

#執行結果
Go
4

3）元組迴圈與判斷

#在tuple1裡，通過enumerate關鍵字，獲取索引與元素
for index,itme in enumerate(tuple1):
	print(index,itme)
#判斷是否有元素[Go]，若有，則輸出“學習Go語言”
if index==4 and itme[0]=='Go':
	print('學習Go語言')
    
#執行結果
2
2
Go
4
0 1
1 a
2 2
3 1
4 ['Go', 'Python', (1, 2, 3, '4')]
學習Go語言

Process finished with exit code 0
 

字典（dict）

1、字典特性

1）字典是無序的

2）字典是key-value的形式來儲存的

2、字典的關鍵字是dict

for example:
      dict1={'name':'zhangli','age':'18','city':'xian'}

3、排序規則

1）如果是數字，預設是從小到大

2）如果是字串，內部處理思路是將字串轉為數字，然後和1的規則相同

3）如果是多個字串比如aa,ab，那麼這個時候它的規則是：  

A、aa和ab先比較第一個字串，發現第一個相同，就比較第二個  

B、比較第二個，比如是字串轉為數字，規則與1相同

4、字串轉為數字

把字串轉為數字，使用內部函式是ord( )

5、字典排序

排序必須是相同的資料內型,字典排序使用到的內部函式是sorted( )

6、程式設計實訓

1）建立字典

#建立字典
dict1={'name':'zhangli','age':'18','city':'xian'}
print(dict1)

#執行結果
{'name': 'zhangli', 'age': '18', 'city': 'xian'}

2）獲取key與valus（字典迴圈）

#獲取key
for itme in dict1.keys():
	print(itme)
#獲取valus
for itme in dict1.values():
	print(itme)
#獲取所有的key與valus
for key,valus in dict1.items():
	print(key,valus)
    
#執行結果
name
age
city
zhangli
18
xian
name zhangli
age 18
city xian

Process finished with exit code 0

3）獲取valus的值

通常使用第二種方法

#獲取valus的值
print(dict1.get('age'))
print(dict1['age'])

#執行結果
18
18

4）兩個字典合併

#兩個字典合併
dict2={'name':'zhangli','age':'18','city':'xian'}
dict3={'valary':'1800'}
dict2.update(dict3)
print(dict2)

#執行結果
{'name': 'zhangli', 'age': '18', 'city': 'xian', 'valary': '1800'}

5）字典排序

#字典排序
dict4={'name': 'zhangli', 'age': '18', 'city': 'xian', 'valary': '1800'}
print(
	dict(
		sorted(dict4.items(),key=lambda item:itme[0])
)
)
print(
	dict(
		sorted(dict4.items(),key=lambda item:item[1])
	)
)

#執行結果
{'name': 'zhangli', 'age': '18', 'city': 'xian', 'valary': '1800'}
{'age': '18', 'valary': '1800', 'city': 'xian', 'name': 'zhangli'}

6）實現字典的有序

#從collections中匯入OrderedDict類
from collections import OrderedDict

dict10=OrderedDict()
dict10['name']='zhangli'
dict10['sex']='男'
dict10['school']='一般學校'
print(dict(dict10))

#執行結果
{'name': 'zhangli', 'sex': '男', 'school': '一般學校'}

資料轉換

1、字串與列表的轉換

#字串轉換位列表
str1='go,java,python'
str_list=str1.split()
print(str_list)
#列表轉換為字串
list_str=','.join(str_list)
print(list_str)

#執行結果
['go,java,python']
go,java,python

2、列表與元組的轉換

#列表轉換為元組
list1=['go,java,python']
list_tuple=tuple(list1)
print(list_tuple)
#元組轉換為列表
tuple_list=list(list_tuple)
print(tuple_list)

#執行結果
('go,java,python',)
['go,java,python']

3、字串與整形的轉換

#字串轉換為整形
age='18'
salary='1800'
age1=int(age)
salary1=int(salary)
print(type(age1),age1)
print(type(salary1),salary)
#整形轉換為字串
age2=str(age1)
salary2=str(salary1)
print(type(age2),age2)
print(type(salary2),salary2)

#執行結果
<class 'int'> 18
<class 'int'> 1800
<class 'str'> 18
<class 'str'> 1800

4、列表與字典的轉換

#列表轉換為字典
list2=['a','b','c']
list_dict=dict(enumerate(list2))
print(list_dict)
#字典轉換為列表
dict_list=list(list_dict.items())
print(dict_list)

#執行結果
{0: 'a', 1: 'b', 2: 'c'}
[(0, 'a'), (1, 'b'), (2, 'c')]

檔案操作

1、檔案操作

檔案操作又名IO操作，其主要包括讀與寫兩個操作

2、函式的特性

函式特點： 函式有引數    x=f(y)--->y是函式f的引數

3、檔案操作三個步驟

1）開啟檔案（open）

2）操作檔案（write）【針對檔案的讀與寫】

3）關閉檔案（close）【檔案必須關閉，否則會出現記憶體洩露】

4、open函式引數

1）open函式
     作用：IO操作檔案
     引數：
            file：指的是被操作的檔案(預設有路徑）
            mode：通過什麼方式操作檔案（讀還是寫？）
                      a：追加
                      w：寫檔案內容（替換寫入）
                      r：讀取檔案內容
            encoding：編碼（utf-8，gbk）
     寫的操作：
           1、不管是否有檔案，即使沒有檔案，open內部會自動建立一個檔案，
                然後把寫的內容寫進去
     讀的操作
           1、檔案存在，那麼從檔案中讀取資料
           2、檔案不存在，會報【FileNotFoundError】的錯誤資訊
                如： [Errno 2] No such file or directory: 'acd.docx'
     with上下文：with open() as f:
           他內部可以對檔案進行關閉，這樣避免了操作檔案忘記關閉

5、實訓程式設計

1）寫：wirte

#在檔案中寫入“hello Python”
f=open(file='login.txt',mode='w',encoding='utf-8')
f.write('hello Python!')
f.close()

#刪除檔案原有內容，重新寫入“Spark”
f=open(file='login.txt',mode='w',encoding='utf-8')
f.write('Spark')
f.close()

#寫入多行內容
f=open(file='login.txt',mode='w',encoding='utf-8')
data='''
hadoop
spark
hive
hbase
flink
kafka
'''
#輸出讀取內容，並取消空格（strip）
f.writelines(data.strip())
f.close()

2）讀：read

#讀取檔案裡面所有內容
f=open(file='login.txt',mode='r',encoding='utf-8')
print(f.read())
f.close()

#讀取檔案裡面第一條內容
f=open(file='login.txt',mode='r',encoding='utf-8')
print(f.readline())
f.close()

#按行讀取檔案所有內容
f=open(file='login.txt',mode='r',encoding='utf-8')
for item in f.readlines():
#輸出讀取內容，並取消空格（strip）
	print(item.strip())
f.close()
#在非預設路徑下讀取檔案內容
f=open(file='D:/admin.txt',mode='r',encoding='utf-8')
print(f.read())
f.close()

 3）with上下文

格式：with open() as f:

#with上下文
with open(file='D:/admin.txt',mode='r',encoding='utf-8') as f:
	print(f.read())

函式

1、定義

所謂函式，就是把重複的程式碼單獨的分離出來，放在⼀個公共的地⽅，

以後可以⼀直的進⾏調⽤，這樣就可以解決多次重複來編寫。

2、關鍵字

函式定義的關鍵字：def

for example：
    def 函式名稱（函式的引數）：
        函式表示式

3、函式呼叫

函式寫完後，必須要經過呼叫才可以生效，如果不呼叫，不會生效

呼叫函式的方式是：函式名稱

4、引數分類

1）形式引數：函式裡面的引數叫形式引數

2）實際引數：函式被呼叫的時候，給予引數賦予的值叫實際引數

3）預設引數：在定義函式的時候給形式引數指定了引數的值

4）動態引數：定義一個函式的時候，當函式的形式引數個數不確定，資料型別不確定的時候

5、引數呼叫注意事項

1）函式在呼叫的時候，可以填寫形式引數，也可以不填寫。

2）要麼填寫，要不都不填寫

3）函式在呼叫的時候，填寫的實際引數要與形式引數的順序、個數保持一致

4）函式有形式引數的時候，呼叫函式必須填寫實際引數

6、動態引數

*：代表的是元組的資料型別

**：代表的是字典的資料型別

7、內部函式

關鍵字

數字轉字母：chr；字母轉數字：ord；

包含開始,但不包含結尾：range

8、匿名函式（lambda）

指定一個函式，但是這個函式的名字是可以自定義的 。

for example:
	a=lambda x,y:x+y
    
其中:左邊是函式的形式引數
	:右邊是函式的表示式

9、過濾函式（filter）

一共三種方式：普通過濾，過濾，匿名過濾

10、迭代增加（map）

針對所有物件做同樣的操作

使用前提：1、函式物件 ；2、可迭代的物件

11、函式返回值（return）

一個函式，不管是否有return，它都有返回值的，如果沒有return，它的返回值是None

如果有return，函式的返回值是return後面的內容，切記：return後面的程式碼是不能執行的

函式返回值的價值是：把函式與函式能夠建立一層關聯關係

12、實訓程式設計

1）定義函式

#定義函式，填寫形式引數
def add(a,b):
	print(a+b)
#給予引數賦值（實際引數）
add(3,6)

#定義函式，填寫預設引數
def login(username="admin",password="message"):
	print(username+","+password)
#執行函式
login()

#定義函式，填寫動態引數
def func(*args,**kwargs):
	print(*args,**kwargs)
func({'name','zhangli'})

#執行結果
9
admin,message
{'name', 'zhangli'}

2）登入賬戶

#登入賬戶
def login(username,password):
	if username=='zhangli' and password=='123456':
		print('登入成功')
	else:
		print('登入失敗')

login(username='zhangli',password='123456')

#執行結果
登入成功

3）註冊賬戶，並讀取至檔案

#註冊賬戶
def registry():
	username=input('請輸入使用者名稱：\n')
	password=input('請輸入密碼：\n')
	temp=username+','+password
	with open('login.txt','w') as f:
		f.write(temp)
registry()

#執行結果
1）建立了login.txt檔案，且顯示zhangli,123456
2）執行結果欄結果：
   請輸入使用者名稱：
   zhangli
   請輸入密碼：
   123456

4）讀取內容到檔案

寫一個函式，將註冊的賬號讀取後，寫入login.txt檔案裡，並單獨輸出使用者名稱

def registry():
	with open('login.txt','r') as f:
		acd=f.read().split(',')
		print(acd[0])
registry()

def registry():
	with open('login.txt','r') as f:
		for item in f.readlines():
			print(item.split(',')[0])
registry()

#執行結果
zhangli
zhangli

5）動態引數

#輸入元組資料
def func(*args):
	print(args)
	print(type(args))

func([1,2,3])
func((1,2))
func({'name','zhangli'})

#輸入字典資料
def func(**kwargs):
	print(kwargs)
	print(type(kwargs))

func(name='zhangli',age=18)
func(**{'name':'age'})

#使用場景
def func(*args,**kwargs):
	print(kwargs)

func(payType='alipay',price=100)
func(payType='wxpay')
func(payType='zhaohang',price=100,city='xian')

def func(*args,**kwargs):
	print(kwargs)

func(payType='alipay',price=100)
func(payType='wxpay')
func(payType='zhaohang',price=100,city='xian')

6）內部函式

#數字轉字母（chr）
print(chr(98))

#字母轉數字（ord）
print(ord('d'))

#包含開始,但不包含結尾（range）
for item in range(1,5):
	print(item)
#匯入（import)
import random#內部庫，庫都是需要匯入，匯入關鍵字為import
print(random.randint(1,100))#隨機生成數字（5個）

#字串轉為字串(eval)
str1='5+5'
print(eval(str1))

#執行函式
b

100

1
2
3
4
24

10

 7）驗證碼生成（隨機生成）

list1=[]
#隨機迴圈生成10個數字
for i in range(10):
#在（97，120）之間隨機取數，並放入變數r中；前提條件：生成10個數
	r=random.randint(97,120)
#將變數寫入列表中，且將數字轉換為字母
	list1.append(chr(r))
#將數字轉換為字串，並輸出
print(''.join(list1))

#dgawdqxiud

8）匿名函式（lambda）

a=lambda x,y:x*y
print(a(4,5))

#執行結果
20

9）過濾大於2的數字（過濾函式）

#普通方法
list2=[1,2,3,4,5,6,7,8,9]
list3=[]
def func():
	for item in list2:
		if item>2:
			list3.append(item)
	print(list3)

func()

#過濾（filter）
list2=[1,2,3,4,5,6,7,8,9]
def func(a):
	if a>2:
		return True

print(
	list(filter(func,list2))
)


#過濾（filter加lambda）
list2=[1,2,3,4,5,6,7,8,9]
print(
	list(filter(lambda x:x>2,list2))
)

#執行結果
[3, 4, 5, 6, 7, 8, 9]
[3, 4, 5, 6, 7, 8, 9]
[3, 4, 5, 6, 7, 8, 9]

10）對各個變數加10

#map迭增方法
list2=[1,2,3,4,5,6,7,8,9]
print(list(map(lambda x:x+10,list2)))

#for迴圈方法
list4=[]
def func():
	for item in list2:
		list4.append(item+10)
	print(list4)
func()

#執行結果
[11, 12, 13, 14, 15, 16, 17, 18, 19]
[11, 12, 13, 14, 15, 16, 17, 18, 19]

11）登入返回sessionid

#登入返回sessionid
def zhihulogin(username='zhangli',password='admin'):
	if username=='zhangli' and password=='admin':
		return 'we456ertre'
	else:
		return"賬戶或密碼不對"

#判斷返回的sessionid引數是否與客戶端sessionid一致
def profile(sessionid):
	if sessionid=='we456ertre':
		print("歡迎檢視知乎主頁")
	else:
		print("請登入！")

#若想登入成功，必須滿足賬戶與密碼正確，因此預設引數和實際引數必須為正確的賬戶與密碼
profile(sessionid=zhihulogin())
profile(sessionid=zhihulogin('zhangli','admin'))
profile(sessionid=zhihulogin('zl,admin'))
profile(sessionid=zhihulogin('we456ertre'))

#執行結果
歡迎檢視知乎主頁
歡迎檢視知乎主頁
請登入！
請登入！

全域性變數與區域性變數

1、定義

全域性變數：在一個python檔案中定義的變數

區域性變數：在一個函式中定義的變數

2、優先順序

1）在python檔案中，呼叫變數，全域性變數優先順序是高於區域性變數的

2）在函式內部呼叫變數，區域性變數的優先順序是高於全域性變數的

3）如果在函式內部想引用全域性變數，那麼使用關鍵字global

#在python檔案中，呼叫變數，全域性變數優先順序是高於區域性變數的
name='無涯'
def func():
	name='wuya'
print(name)

#在函式內部呼叫變數，區域性變數的優先順序是高於全域性變數的
name='無涯'
def func():
	name='wuya'
	print(name)
func()

#如果在函式內部想引用全域性變數，那麼使用關鍵字global
name='無涯'
def func():
	global name
	print(name)
func()

#執行結果
無涯
wuya
無涯

模組與包

1、在python中，每一個python檔案都是一個模組（modyle）

2、包：在一個包裡面會很多的模組

3、包與資料夾的區別：包裡面有_init_.py檔案；資料夾沒有

4、一個模組呼叫另一個模組檔案的變數以及函式：form package.module import *（代表所有）

for example:

#呼叫login.txt，輸出login所有內容
from login.f1 import *

print(name)
func()