python基礎知識點小結(2021/2/9)

\quad 入門小知識

\quad \quad cmd

在cmd上進行python，直接輸入 p y t h o n \quad python python
退出cmd輸入 e x i t ( ) \quad exit() exit()
到指定檔案夾上運行python檔案 p y t h o n 路徑文件名 . p y \quad python 路徑檔案名.py python路徑文件名.py

\quad \quad python注釋

單行注釋 # \quad\# #
多行注釋 ′ ′ ′ ′ ′ ′ \quad ''''''\quad ′′′′′′ 6個單引號
當python 使用中文時，有時候會出錯，記得加上

	# -*- coding:utf-8 -*-

\quad \quad 變數、識別符號和關鍵字

變數

p y t h o n python python變數可以是任意資料型別，命名規則和 c , c + + c,c++ c,c++相同
python值得一提的是他的變數本質，類似于標簽和指標

關鍵字

是已經被 p y t h o n python python內部使用的名稱
i m p o r t k e y w o r d ; k e y w o r d . k y l i s t import\quad keyword; \quad keyword.kylist importkeyword;keyword.kylist

\quad \quad 輸出與輸入

輸出

普通的輸入輸出 p r i n t ( ′ 這是普通輸入輸出 ′ ) \quad print('這是普通輸入輸出') print(′這是普通輸入輸出′)
格式化輸入輸出 p r i n t ( ′ 我的姓名是 % s , 我的年齡是 % d ′ % ( n a m e , a g e ) ) \quad print('我的姓名是\%s,我的年齡是\%d'\%(name, age)) print(′我的姓名是%s,我的年齡是%d′%(name,age))
同c++,c一樣，使用 \quad '\n’ \quad 換行
常見的格式符號如下

輸入

接收變數 = input(‘輸入提示’);
注意接收的輸入
input接受的資料是字串，想要變成整數啥的，需要使用 i n t ( ) , e v a l ( ) , f l o a t ( ) , s t r ( ) \quad int(),\quad eval(),\quad float(),\quad str() int(),eval(),float(),str()
下面看幾個有趣的實驗

# 運算式的計算直接就使用 eval()，簡單方便好使
>>> a = 123
>>> b = eval(input())
a * 2
>>> b
246

\quad \quad 運算子和運算式

算數運算子
在這里插入圖片描述

注意，負數求余的正負，關鍵是看 % \quad \% \quad %后數字的正負
小實驗

>>> a = 12.5
>>> b = 2
>>> a % b
0.5
>>> a / b
6.25
>>> a // b
6.0
>>> a ** b
156.25
>>> b ** a
5792.618751480198
>>> -15 % -2	# 余數的正負，跟隨 % 后數的正負
-1
>>> 15 % -2
-1
>>> -15 % 2
1
>>> 15 % 2
1

比較運算子
在這里插入圖片描述
賦值運算子

位運算子
在這里插入圖片描述

邏輯運算子和成員運算子
在這里插入圖片描述
身份運算子

運算子優先級
\quad\quad\quad\quad\quad

\quad 判斷陳述句&回圈陳述句&呼叫庫

注意 : 冒號

\quad\quad 判斷陳述句

理論講解

if ~ else ~
if ~ elif ~ elif ~~~ else
嵌套
注意要縮進！！
石頭剪刀布小游戲 py 代碼

\quad\quad 呼叫py庫

將整個模塊匯入 i m p o r t s o m e _ m o d u l e \quad import \quad some\_module importsome_module
從某個模塊中匯入某個函式 f r o m s o m e _ m o d u l e i m p o r t s o m e _ f u n c t i o n \quad from \quad some\_module \quad import \quad some\_function fromsome_moduleimportsome_function
從某個模塊中匯入多個函式 f r o m s o m e _ m o d u l e i m p o r t f i r s t _ f u n c , s e c o n d _ f u n c . . . \quad from \quad some\_module \quad import \quad first\_func,second\_func... fromsome_moduleimportfirst_func,second_func...
將某各模塊中的函式全部匯入 f r o m s o m e _ m o d u l e i m p o r t \quad from \quad some\_module \quad import \quad fromsome_moduleimport \*

import random as rd
'''
規則: 剪刀(0)，石頭（1），布（2），退出（3），其他輸入都是不合法
    首先是一個while回圈，然后不斷的接收輸入的資料，
    輸入資料合法
        是退出信號
            直接退出  
        石頭剪刀布
            我們的random資料做比較，輸出你贏了，你輸了，是平局
    輸入不合法
        要求重新輸入，并說出游戲規則
'''
gesture = ["石頭", "剪刀", "布"];
while True:
    print('--------------------------------------------------------');
    _data = input('規則: 剪刀(0)，石頭（1），布（2），退出（3），其他輸入都是不合法\n請輸入資料:')
    _rdm = rd.randint(0, 2);
    if _data == '0' or _data == '1' or _data == '2':    # 合法的正確輸入，和亂數比大小
        _data = int(_data);
        print('玩家出的是%s' % gesture[_data]);
        print('電腦出的是%s' % gesture[_rdm]);
        if _data == _rdm:
            print("雙方平局");
        elif _data == 0 and _rdm == 2 or _data == _rdm + 1:
            print('玩家贏了');
        else:
            print('玩家輸了');
    elif _data == '3':      # 游戲退出
        print('游戲結束');
        break;
    else:                   # 非法輸入
        print('輸入資料錯誤，請重新輸入');
        continue;

\quad\quad 回圈陳述句(for&while ? \Rightarrow ?break&continue&pass)

for回圈形式
借助range()

注意range(start, end, step), 從start開始，步長為step，一直到end(但是取不到end)

for i in range(5):	# 輸出的是 0~4，不會到5的
	print(i);
for i in range(1, 6, 2):	# 輸出的是1, 3, 5
	print(i);

用于串列和字串

name = 'tengzhou'
for i in name:	#會把	tenghzhou	在一行輸出
	print(i, end='');

while回圈形式
練習1~n的累加和，和偶數的累加和

n = 100;
sum_all = 0; sum_even = 0; i = 1;
while i <= n:
    sum_all += i;       # 任意數
    if (i & 1) == 0:    # 偶數
        sum_even += i;
    i += 1
print('1~100的數字和為:', sum_all);
print('1~100的偶數和為:', sum_even);

break, continue, pass陳述句
break, continue, pass的區別與聯系
在這里插入圖片描述
練習列印九九乘法表

i = 1;
j = 1;
# 列印 i * j
# i 作為外層回圈，j 作為內層回圈
while i <= 9:
    j = 1;
    while j <= i:
        if j < i:
            print("%d * %d = %2d" % (i, j, i * j), end = ', \t');
        else:
            print("%d * %d = %2d" % (i, j, i * j));
        j += 1;
    i += 1;

\quad 字串&串列&元組&字典&集合

\quad\quad 字串

String字串

常用單引號、雙引號、三引號括起來，使用反斜杠 \ 來進行轉義特殊字符.
Python3默認UTF-8進行編碼，所有字串都是unicode字串，
支持字串的拼接、截取等等多種運算，
使用str 進行強制型別轉化

單引號、雙引號、三引號選取的區別與聯系 <\font>

下面我們給出幾個例子來看出使用單引號和雙引號的區別
example 1: 字串 I’am a student

使用單引號 ‘I’am a student’ ? \Rightarrow ?必須使用轉義字符
使用雙引號 “I’m a student” ? \Rightarrow ?直接寫就可以

example 2:字串 Tom said "I like you"

使用單引號 ‘Tom said “I like you”’ ? \Rightarrow ?直接寫就可以
使用雙引號 “Tom said “I like you”” ? \Rightarrow ?必須使用轉義字符

三引號的應用：可以不在一行

有時被用于注釋，其實注釋的就是未被變數標記的字串

下面看一下在代碼中的顯示
其中str1=str2, str3 = str4, s1=s2=s3=s4

# 單引號的和雙引號的區別，關鍵在于轉義字符
str1 = 'I\'am a student';
str2 = "I'am a student";
str3 = 'She said "I like you"';
str4 = "She said \"I like you\""
print('str1=', str1);
print('str2=', str2);
print('str3=', str3);
print('str4=', str4);
# 三引號
s1 = '''line1
line2'''
s2 = 'line1\nline2'
s3 = "line1\nline2"
s4 = 'line1\
\nline2'
print('s1=', s1);
print('s2=', s2);
print('s3=', s3);
print('s4=', s4);

轉義字符
在這里插入圖片描述
字串的截取與連接

print(str[0:7:2]); # [起始：終止：步長]–>[st:step:ed]，注意是取不到 ed 的
print(r’hello\npython’); # 在字串面前加一個 r 表示原始字串，不會發生轉義，
print(str[0:-1]); # 輸出字串0到倒數第二個，其實-1表示是最后一個，但是[st:ed]取不到最后一個，
直接上代碼的示例

# 字串的截取與連接
str = "shandong"

print(str);         # 輸出字串
print(str[:]);      # 輸出字串
print(str[0:])      # 輸出字串
print(str[0:-1]);   # 輸出字串0到倒數第二個
print(str[0]);      # 輸出第0個字符, 從0開始計數
print(str[2:5]);    # 輸出第2個到第4個字符，從0開始計數
print(str[2:]);     # 輸出第2個到最后
print(str * 2);     # 輸出兩遍
print(str + 'tengzhou') # 字串連接后輸出
print(str[:5]);     # 輸出從第0個到第5個字符
print(str[0:7:2]);  # [起始：終止：步長]-->[st:step:ed]，注意是取不到 ed 的

print('------------------------------');
print('hello\nshandong');
print(r'hello\npython');    # 在字串面前加一個 r 表示原始字串，不會發生轉義，

字串的常見操作
在這里插入圖片描述

\quad\quad 串列

串列中的資料結構可以不同，支持數字、字串，也可以包括自身（串列的嵌套），
串列元素寫在 [] 之間，用 ‘,’分隔開，eg:list = [‘abcd’, 123, 2.123, ‘python’, 36.5];
索引值和 str類似，0表示開始數值， -1表示末尾的開始位置
同 string 相同， + 表示串列的拼接， * 表示串列的重復

串列的定義與訪問
詳情請看下面的代碼示例

test_list = ['shanghai', 'beijing', "hunan", 123];
for x in test_list:             # 輸出形式 1
    print(x);
for i in range(len(test_list)): # 輸出形式 2
    print(test_list[i]);

串列的常用操作

直接下標訪問、切片、遍歷串列
增加：append(element), extend(List)相當于將串列中的元素遍歷進行append(), insert()插入到具體的位置
洗掉：del(idx), remove(val), pop(void)
修改，直接進行下標訪問進行修改
查詢是否在串列中， In， not in
+ 用于連接
串列的排序sort()，翻轉的reverse()
長度，最大值、最小值、強制型別轉換: len, max, min, list;

串列的嵌套
在這里插入圖片描述

import random

offices = [[], [], []];     # 三個辦公室
teacher = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']; # 8個教室

for tea_name in teacher:
    tmp = random.randint(0, 2);
    offices[tmp].append(tea_name);

i = 1;
for off in offices:
    print('辦公室%d有%d人'%(i, len(off)), end='\n\t');
    for tea in off:
        print(tea, end=' ');
    print('');
    print('-'* 10);
    i += 1;

編程作業
在這里插入圖片描述
作業的實作的代碼如下：

# 商品資料定義
products = [["iphone", 6888], ["MacPro", 14800], ["XiaoMin6", 2499],
            ["Coffee", 31], ["Book", 60], ["Nike", 699]];

# 商品顯示
i = 0;
print('-'*6, '  商品串列  ', '-'*6);
for goods in products:
    print('%d\t'%i, goods[0], '\t', goods[1]);
    i += 1;

# 商品購買的回圈
buy_goods = [];
while True:
    tmp = input('請輸入商品標號，或者是輸入q退出\n');
    if tmp == 'q':
        print('退出成功');
        break;
    elif tmp.isnumeric():
        tmp = eval(tmp);
        if tmp < 0 or tmp >= len(products):
            print('資料輸入錯誤，請重新輸入');
            continue;
        else:
            buy_goods.append(products[tmp]);
    else:
        print('資料輸入錯誤，請重新輸入');
        continue;

# 列印購買的商品和總價
print('-'*6, '  購買的商品為  ', '-'*6);
money = 0;
for goods in buy_goods:
    print('%s\t%d'%(goods[0], goods[1]));
    money += goods[1];
print('總價=%d'%money);

\quad\quad 元組

元組與list類似，但是tuple的資料不可以被修改，元素寫在小括號里面，元素之間用逗號分開，
元組的元素不可變，但是可以包括可變物件，eg：list，而且list內部是可以加的
定義只有一個元素的tuple，必須加逗號，因為不加逗號就看成是一個加括號的運算式

代碼嘗試：

my_tuple = ([1, 2, 3],);
for i in my_tuple:  # 原本 tuple 元素的遍歷輸出
    print(i);
    
my_tuple[0].append(2);  # 添加的新元素

for i in my_tuple:  # 原本 tuple 元素的遍歷輸出
    print(i);
    
for i in my_tuple:  # 標簽指的是一個地方，是被洗掉的！！，相當于參考
    i.pop();
    
for i in my_tuple:
    print(i);

結果

[1, 2, 3]
[1, 2, 3, 2]
[1, 2, 3]

元組的定義和訪問

創建一個空元祖
元組的定義
元組的訪問
元組的元素值是不允許修改的，但是我們可以對元組進行連接組合形成一個新的元組，
將元組洗掉釋放之后，再次訪問會報錯，是非法的，

# 創建空元祖
tuple1 = ();

# 創建僅僅一個元素的元組
tuple1 = (2, );     # 注意，元組指向記憶體單元的內容不可以改，但是變數作為便簽是可以指向其他地方的
int1 = (2);         # 這個不加逗號的不是元組，是一個整數運算式

# 元組的訪問
tuple1 = ('Google', 'baidu', 2000, 2020);
tuple2 = (1, 2, 3, 4, 5, 6, );  # 這個后面的逗號是可加可不加的
print("tuple1[0]=%s"%tuple1[0]);
print("tuple1[2]=%d"%tuple1[2]);
print("tuple1[2]=%s"%tuple1[2]);
print('%s'%1);      # 整數也是可以直接 %s 轉換為 string 型別的
print(str(1));
print('tuple2[1~5]:', tuple2[1:5]);

# 假設元組某個元素是可變型別list，我們看看list是否可以正常修改 --> 是可以正常修改的
tup3 = ([0], );
print(type(tup3));
for x in tup3:
    print(x);
x.extend([2, 3, 4, 5, 6]);
x.pop();
for y in tup3:
    print(y);

# 嘗試修改其他的
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');
# 下面的操作是非法的
# tup1[0] += 2;
# 我們可以進行元組的連接
tup3 = tup1 + tup2;
for i in tup3:
    print(i);

# 我們釋放一下tup1記憶體試一試
del tup1
print(tup3);    # 這個是ok的，所以說tup3是新開的記憶體
print('-' * 6);
''' 都報錯，說明還是別用了，釋放之后，在為重新賦值之前就別用，
i = tup1;
print('1', type(i));
# print(tup1);    # 什么都輸出不了了，被釋放了
'''