Python編程基礎-練習代碼合集

1.初識Python

• 猜數字游戲

from random import randint


def play():
    random_int = randint(0, 100)

    while True:
        user_guess = int(input("請輸入可猜測的數字(0-100)："))

        if user_guess == random_int:
            print(f"你找到了數字({random_int})太厲害了！")
            break

        if user_guess < random_int:
            print("猜小啦！")
            continue

        if user_guess > random_int:
            print("猜大啦！")
            continue


if __name__ == '__main__':
    play()

2.Python語法基礎

• 求矩形面積

# rect_length = 6
# rect_width = 3
# rect_area = rect_length * rect_width
# print('長方形的面積是:', rect_area)

rect_length = float(input("請輸入矩形的長(cm):"))
rect_width = float(input("請輸入矩形的寬(cm):"))
rect_area = rect_length * rect_width
print('長方形的面積是:', rect_area)

•  運算符優先級

# print(24 + 12 / 6 ** 2 * 18)  # 6 ** 2 指的是6 的二次方
# print(24 + 12 / (6 ** 2) * 18)
# print(24 + (12 / (6 ** 2)) * 18)
# print(24 + (12 / 6) ** 2 * 18)
# print((24 + 12) / 6 ** 2 * 18)
# print(-4 * 5 + 3)
# print(4 * - 5 + 3)

print(15 + -20 - 2 ** 3)  # 結果=-13
# 先算2的3次方，再從左往右進行加減，其中-20表示負20，即15減20


print(5 % 2 + 3 // 2 - 2 * 6 / 12)  # 結果=1.0
# 由於運算符的優先級，此式子等同於：
# print((5 % 2) + (3 // 2) - (2 * 6 / 12))
# 其中,%表示求余數（5除2等2余1，結果取1），//表示取整除（3除2等於1.5，結果取1）


print(4 & 4 >> 1)  # 結果=0
# 由於運算符的優先級，此式子等同於：
# print(4 & (4 >> 1))
# 其中,4 >> 1 = 2,4 & 2 =0


print(2 <= 3 ^ 2)
# 由於運算符的優先級，此式子等同於：
# print(2 <= (3 ^ 2))
# 其中，3 ^ 2 =1,2 <= 1 為False


a = 3 != 2
print(a)
# 由於運算符的優先級，此式子等同於：
# a = (3 != 2)
# print(a)   為True
print('----------')

a = 11
b = 11
print(a is b)

List = [1, 2, 3.0]
print(1 in List)

A = True
B = False
print(A and B)

 

•  明文密文

message = input('請輸入一個字母：')
m_Pwd = chr(ord(message) + 3)  # 將數輸入的字母轉換成數字加3后在轉回字母，結果為： d
print('明文：', message)
print('密文：', m_Pwd)
m_Pwd_jm = chr(ord(m_Pwd) - 3)
print('解密：')
print('密文：', m_Pwd)
print('解密的明文：', m_Pwd_jm)

• 凱撒密碼

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

# @Date    : 2018-10-12
# @Author  : Peng Shiyu

class CaesarCipher(object):
    """
    凱撒加密解密
    """

    def __crypt(self, char, key):
        """
        對單個字母加密，偏移
        @param char: {str} 單個字符
        @param key: {num} 偏移量
        @return: {str} 加密后的字符
        """
        if not char.isalpha():
            return char
        else:
            base = "A" if char.isupper() else "a"
            return chr((ord(char) - ord(base) + key) % 26 + ord(base))

    def encrypt(self, char, key):
        """
        對字符加密
        """
        return self.__crypt(char, key)

    def decrypt(self, char, key):
        """
        對字符解密
        """
        return self.__crypt(char, -key)

    def __crypt_text(self, func, text, key):
        """
       對文本加密
       @param char: {str} 文本
       @param key: {num} 偏移量
       @return: {str} 加密后的文本
       """
        lines = []
        for line in text.split("\n"):
            words = []
            for word in line.split(" "):
                chars = []
                for char in word:
                    chars.append(func(char, key))
                words.append("".join(chars))
            lines.append(" ".join(words))
        return "\n".join(lines)

    def encrypt_text(self, text, key):
        """
        對文本加密
        """
        return self.__crypt_text(self.encrypt, text, key)

    def decrypt_text(self, text, key):
        """
        對文本解密
        """
        return self.__crypt_text(self.decrypt, text, key)


if __name__ == '__main__':
    plain = """
    you know? I love you!
    """
    key = 3

    cipher = CaesarCipher()

    # 加密
    print(cipher.encrypt_text(plain, key))
    # brx nqrz? L oryh brx!

    # 解密
    print(cipher.decrypt_text("brx nqrz? L oryh brx!", key))
    # you know? I love you!

• 凱撒密碼2

'''
A:65
Z:90
a:97
z:122
0:48
9:57
'''

old_message = input("please input your message：")
new_message = ''
for old_c in old_message:  # old_c是從明文中取出的字符
    if 'A' <= old_c <= 'Z':
        new_c = chr((ord(old_c) - ord('A') + 3) % 26 + ord('A'))
    elif 'a' <= old_c <= 'z':
        new_c = chr((ord(old_c) - ord('a') + 3) % 26 + ord('a'))
    elif '0' <= old_c <= '9':
        new_c = chr((ord(old_c) - ord('0') + 3) % 10 + ord('0'))
    else:
        new_c = old_c
    new_message += new_c  # new_message=new_message+new_c
print("the encrypted message is %s" % (new_message))
# 解密
old_message = ''
for new_c in new_message:  # new_c是從密文中取出的字符
    if 'A' <= new_c <= 'Z':
        old_c = chr((ord(new_c) - ord('A') - 3) % 26 + ord('A'))
    elif 'a' <= new_c <= 'z':
        old_c = chr((ord(new_c) - ord('a') - 3) % 26 + ord('a'))
    elif '0' <= new_c <= '9':
        old_c = chr((ord(new_c) - ord('0') - 3) % 10 + ord('0'))
    else:
        old_c = new_c
    old_message += old_c
print("the decrypted message is %s" % (old_message))

 

•  計算圓形的各參數

import math

# 1.輸入圓的半徑
radius = float(input("請輸入圓的半徑(cm):"))
circle_C = math.pi * 2 * radius
circle_Area = math.pi * math.pow(radius, 2)
# 輸出周長和面積
print("圓的半徑是：", radius, "cm")
print("圓的周長是：,{} \"cm\"".format('%.2f' % circle_C))
print("圓的面積是：, {} \"c㎡\"".format('%.2f' % circle_Area))
print('------分割線------')

# 2.輸入面積
circle_Area = float(input("請輸入圓的面積（c㎡）："))
radius = math.sqrt(circle_Area / math.pi)
circle_C = math.pi * 2 * radius
# 輸出半徑和周長
print("圓的面積是：, {} \"c㎡\"".format('%.2f' % circle_Area))
print("圓的半徑是：, {} \"cm\"".format('%.2f' % radius))
print("圓的周長是：,{} \"cm\"".format('%.2f' % circle_C))
print('------分割線------')

# 3.輸入周長
circle_C = float(input("請輸入圓的周長（cm）："))
radius = circle_C / (math.pi * 2)
circle_Area = math.pi * math.pow(radius, 2)
print("圓的周長是：,{} \"cm\"".format('%.2f' % circle_C))
print("圓的半徑是：, {} \"cm\"".format('%.2f' % radius))
# 輸出半徑和周長
print("圓的面積是：, {} \"c㎡\"".format('%.2f' % circle_Area))

 

• 回文數

number = input('請輸入一個數：')
s1 = number[::-1]
# print(s1)
if number == s1:
    print("您輸入的'{0}'是回文數".format(number))
else:
    print("您輸入的'{0}'不是回文數".format(number))

 

•  輸出星座

"""
實訓1 對用戶星座進行分析並輸出結果
"""
print('-----星座小程序------')
name = input("請輸入您的名字：")
print('星座日期對應表：')
print("編號\t\t星座\t\t日期  \n"
      "1\t\t水瓶\t\t1月20~2月18\n"
      "2\t\t雙魚\t\t2月19~3月20\n"
      "3\t\t白羊\t\t3月21~4月19\n"
      "4\t\t金牛\t\t4月20~5月20\n"
      "5\t\t雙子\t\t5月21~6月21\n"
      "6\t\t巨蟹\t\t6月21~7月22\n"
      "7\t\t獅子\t\t7月23~8月22\n"
      "8\t\t處女\t\t8月23~9月22\n"
      )
print(name, "，您好！請根據如上提示選擇編號：")
number = input()
if number == '1':
    print(name, '，您好！水瓶座的您星座分析結果：編號：1\t星座：水瓶座\t日期：1月20~2月18\n')

elif number == '2':
    print(name, '，您好！雙魚座的您星座分析結果：編號：2\t星座：雙魚座\t日期：2月19~3月20\n')
elif number == '3':
    print(name, '，您好！白羊座的您星座分析結果：編號：3\t星座：白羊座\t日期：3月21~4月19\n')
elif number == '4':
    print(name, '，您好！金牛座的您星座分析結果：編號：4\t星座：金牛座\t日期：4月20~5月20\n')
elif number == "5":
    print(name, '，您好！雙子座的您星座分析結果：編號：5\t星座：雙子座\t日期：5月21~6月21\n')
elif number == '6':
    print(name, '，您好！巨蟹座的您星座分析結果：編號：6\t星座：巨蟹座\t日期：6月21~7月22\n')
elif number == '7':
    print(name, '，您好！獅子座的您星座分析結果：編號：7\t星座：獅子座\t日期：7月23~8月22\n')
elif number == '8':
    print(name, '，您好！處女座的您星座分析結果：編號：8\t星座：處女座\t日期：8月23~9月22\n')
else:
    print('您的輸入有誤！')

 

 

•  字符串操作

s = "12,34,45,54 "
a = s.split(",")
print(a)

w = 'waiter'
print(w.strip('inger'))

w = 'running'
print(w.strip("ing"))

w = 'ingrunning'
print(w.rsplit('ing'))

•  格式化輸出成績

Class = input('請輸入您的班級：')
stu_name = input('請輸入您的學生名：')
score1 = float(input('請輸入您第1門課程的成績：'))
score2 = float(input('請輸入您第2門課程的成績：'))
score3 = float(input('請輸入您第3門課程的成績：'))
AVG = (score1 + score2 + score3) / 3

# print('\'{}\'的\'{}\'的第1門課程成績是{},第2門課程成績是{},第3門課程成績是{},平均成績是{}'
#       .format(Class, stu_name, score1, score2, score3, '%.2f' % AVG))

# print('\'%s\'的\'%s\'的第1門課程成績是%f,第2門課程成績是%f,第3門課程成績是%f,平均成績是%.2f'
#       % (Class, stu_name, score1, score2, score3, AVG))

print(f'\'{Class}\'的\'{stu_name}\'的第1門課程成績是{score1},第2門課程成績是{score2},第3門課程成績是{score3},平均成績是{AVG:.2f}')

 

• 格式化輸出

print("我叫%s,今年%d歲！" % ('小明', 10))
print("{} a word she can get what she {} for.".format('With', 'came'))  # 使用{}
print('{pre} a word she can get what she {verb} for.'.format(pre='With', verb='came'))  # 通過關鍵字參數
print('{0} a word she can get what she {1} for.'.format('With', 'came'))  # 通過位置
p = ['With', 'came']
print('{0[0]} a word she can get what she {0[1]} for.'.format(p))  # 通過下標索引
# 相當於:
print(p[0] + '' + ' a word she can get what she ' + p[1] + ' for.')

# 通過復制
city = '廣州'
url = 'http://www.baidu.com={}'.format(city)
print(url)

print('{:.2f}'.format(321.33345))  # 必須要冒號
print('{:,}'.format(1234567890))  # ,逗號作金額的千位分隔符
print('{:b}'.format(17))  # 2進制
print('{:d}'.format(17))  # 10進制
print('{:o}'.format(17))  # 8進制
print('{:x}'.format(17))  # 16進制

 

•  字符型內建函數練習

# 其他：
s = "I love python!"
print(s.count("o"))
print(s.count("love"))
print(s.index("y"))  # index(sub)
print(s.endswith("Python!"))
print(s.endswith("python!"))
print(s.startswith("I"))
print("o在")

print(s.replace("python", "Java"))
print(s.capitalize())  # 一句話中的首字母大寫
print(s.title())  # 每個字符串首字母大寫
print(s.upper())  # 每個字母都大寫
print(s.isalpha())  # 判斷字符串是不是單純的字母
print(s[::-1])
# 回文數
s = "12321"
s1 = s[::-1]
if s == s1:
    print("True")
else:
    print("False")

print('-----分割線-----')
# 練習：
# 學史明理、學史增信、學史崇德、學史力行，以實際行動繼承和弘揚“五四精神”

# Sentence = '學史明理、學史增信、學史崇德、學史力行，以實際行動繼承和弘揚”五四精神“'
# Sentence.count("學史")
# print("“學史”出現的次數是：", Sentence.count("學史"))
# print("句子是是否存在“五四精神”這個詞：", Sentence.endswith("”五四精神“"))

s = "學史明理、學史增信、學史崇德、學史力行，\
以實際行動繼承和弘揚“五四精神”"
substr = "學史"
count = s.count(substr)
print("\"{0}\"在\"{1}\"中出現的次數是：{2}".format(substr, s, count))

sub2 = "五四精神"
isFind = False
if s.find(sub2) != -1:
    isFind = "是"
print("\"{0}\"在\"{1}\"中是否存在：{2}".format(sub2, s, isFind))

• 操作運算符練習

"""
1.算術運算符
2.比較運算符
3.賦值運算符
4.按位運算符
5.邏輯運算符
6.成員運算符
7.身份運算符
"""
# 1.算術運算符
print('1.算術運算符')
print(2 / 1)  # 單斜杠除法
print(type(2 / 1))
print(2 // 1)
print(type(2 // 1))  # 雙斜杠除法

print(1 + 2, 'and', 1.0 + 2)  # 加法和乘法
print(1 * 2, 'and', 1.0 * 2)
print('23除以10,商為:', 23 // 10, '，余數為：', 23 % 10)  # 商和與余數
print(3 * ' Python')  # 字符串的n次重復
print('       ')
print('2.比較運算符')
#
print(1 == 2)
print(1 != 2)
print('下面是字符的比較：')
print('a' == 'b', 'a' != 'b')
print('a' < 'b', 'a' > 'b')
print(ord('a'), ord('b'))  # 查看字母編碼
print(chr(97), chr(98))  # 查看編碼對應的字符
print('下面是符號的比較：')
print('# ' < '$')
print('       ')
print('3.賦值運算符')
# 3.賦值運算符
a = 1 + 2
print(a)
print('a:', a)
a += 4
print('a += 4 特殊賦值運算后,a:', a)
# f += 4
# print(f)

print('       ')
print('4.按位運算符')
# 4.按位運算符
a = 60
b = 13
print('a （60） 的二進制：0011 1100')
print('b （13） 的二進制：0000 1101')
print('a & b :', a & b)
print('a | b :', a | b)
print('a ^ b :', a ^ b)
print('~a :', ~a)
print('a << 2 :', a << 2)
print('a >> 2 :', a >> 2)
print('       ')
print('5.邏輯運算符')
# 5.邏輯運算符
a = 11
b = 22
print('a = 11,b = 22')
print('a and b :', a and b)
print('a or b :', a or b)
print('not(a and b) :', not (a and b))
print('       ')
print('6.成員運算符')
# 6.成員運算符
List = [1, 2, 3.0, [4, 5], 'Python3']
print(1 in List)  # 查看1是否在列表內
print([1] in List)  # 查看[1]是否在列表內
print(3 in List)
print([4, 5] in List)
print('Python' in List)
print('Python3' in List)
print('       ')
print('7.身份運算符')
# 7.身份運算符
a = 11
b = 11
print('a = 11,b =11')
print('a is b :', a is b)
print('a is not b :', a is not b)
print(id(a))  # 查看id地址
print(id(b))
a = 11
b = 22
print('a = 11,b = 22')
print('a is b :', a is b)
print('a is not b :', a is not b)
print(id(a))
print(id(b))

 

 

 

 

• 邏輯運算符例子

# 邏輯運算例子
a, b = 1, 22
print("a and b：", a and b)
print("a or b :", a or b)
print("not b:", not b)

•  列表、元組---->轉字符串

str = "1,2,3,4,5"
new_str = str.split(",")
# print(new_str,type(new_str)) # ['1', '2', '3', '4', '5'] <class 'list'>

# 將列表、元組轉換成字符串
L = ['1', '2', '3', '4', '5']
T = ('1', '2', '3', '4', '5')
print(L, type(L), "\n", T, type(T))
L_join = ",".join(L)
T_join = ",".join(T)
print("\n轉換后：")
print(L_join, type(L_join))  # 1,2,3,4,5 <class 'str'>
print(T_join, type(T_join))

 

 

•  作業

　　實訓1

　　

# -*-coding:utf-8-*-
# 1.實訓1：統計“溫暖”，“活動”出現的次數。
# 2.將字符串“2020年1月14日至18日”中的數字轉化成整數類型並計算結果。
# Str = '2020年1月14日至18日，學校2020年“溫暖點亮夢想，青春不負韶華”送溫暖活動之走訪慰問學生家庭活動順利開展。'
Str = input('請輸入一段字符串：')  # 輸入語句
word1 = '溫暖'  # 用一個變量保存需要提取的字符串
word2 = '活動'
count1 = Str.count(word1)  # 統計字符串出現次數的方法.count()
count2 = Str.count(word2)
print('\"{0}\"在\"{1}\"中出現的次數是：{2}'.format(word1, Str, count1))  # 格式化輸出
print('\"{0}\"在\"{1}\"中出現的次數是：{2}'.format(word2, Str, count2))

number1 = int(Str[0:4])  # 按索引提取需要的字符串並轉換成整型
number2 = int(Str[5:6])
number3 = int(Str[7:9])
number4 = int(Str[11:13])
total = number1 + number2 + number3 + number4  # 轉換后的數據相加並用total變量保存
sentence = Str[0:14]  # 提取字符串“2020年1月14日至18日”並用sentence變量保存
print('"{0}"字符串的計算結果：{1}+{2}+{3}+{4}={5}'.format(sentence, number1, number2, number3, number4, total))  # 格式化輸出

　　 實訓2 

　　

# -*-coding:utf-8-*-
# 1.均值：
import math

num1 = float(input('請輸入第1個數：'))
num2 = float(input('請輸入第2個數：'))
num3 = float(input('請輸入第3個數：'))
average_value = (num1 + num2 + num3) / 3
# 2.方差
variance = ((num1 - average_value) ** 2 + (num2 - average_value) ** 2 + (num3 - average_value) ** 2) / 3

# 3.標准差
standard_deviation = math.sqrt(variance)

print('您輸入的"{0},{1},{2},"的均值為：{3},方差為：{4},標准差為：{5}'
      .format(num1, num2, num3, average_value, variance, standard_deviation))  # 格式化輸出

 

 　　numpy方式

　　

# -*-coding:utf-8-*-
# 實訓2:  通過表達式計算3個數值的均值，方差，標准值

def get_mean_var_std(arr):
    import numpy as np

    # 求均值
    arr_mean = np.mean(arr)
    # 求方差
    arr_var = np.var(arr)
    # 求標准差
    arr_std = np.std(arr, ddof=1)
    print("平均值為：%f" % arr_mean)
    print("方差為：%f" % arr_var)
    print("標准差為:%f" % arr_std)

    return arr_mean, arr_var, arr_std


if __name__ == '__main__':
    arr = [11, 2, 5]
    print(get_mean_var_std(arr))

 

 

 

 　　實訓3

　　

# -*-coding:utf-8-*-
# Python實現字符串格式化輸出的方法 （3種）
# 1.% 2.format 3.格式化f
# 第1種：
name = input('請輸入您的名字：')
print('您好，%s先生,您喜歡Python嗎？' % (name))

# 第2種：
Like = input()
print('你真的{}?'.format(Like))

# 第3種：
answer = input()
print(f'{answer}的話就去搬磚吧！')

 

3.Python數據結構

列表

• 求學生成績

# 1.輸入數據：
stu_score_s = input('請輸入您的成績（成績用逗號分隔）：')  # 輸入的數據是字符串類型
# 2.分離數據得到數據列表：
stu_score_s_L = stu_score_s.split(",")
# print(stu_score_s_L)

# 3.讀取數據列表中的數據進行累加，求平均值
total = 0  # 初始化總成績為0
score_Max = int(stu_score_s_L[0])  # 將列表中的第一個數保存到max中
score_L = len(stu_score_s_L)  # 列表長度

for i in range(0, score_L):  # 從0到len(L),i用來做列表的索引號 range函數產生一組自然數序列
    # 循環取數據並進行累加
    total += int(stu_score_s_L[i])  # 把字符串類型轉換為int類型
score_Avg = total / score_L  # 求平均成績

# 求最大值：
for i in range(0, score_L):
    stu_score_s_L[i] = int(stu_score_s_L[i])
    if stu_score_s_L[i] > score_Max:  # 比較最大值
        score_Max = stu_score_s_L[i]  # 替換最大值

# 求偶數和：
total_even = 0
for i in range(0, score_L):
    # 循環讀取數據並進行偶數累加
    stu_score_s_L[i] = int(stu_score_s_L[i])  # 強制類型轉換
    if stu_score_s_L[i] % 2 == 0:  # 判斷是否是偶數
        total_even += stu_score_s_L[i]  # 偶數和累加

# 4.顯示平均成績，最大值，偶數和：
print('您的平均成績是：{0:.1f}'.format(score_Avg))
print('您的最高成績是：{0:.1f}'.format(score_Max))
print('您的偶數和成績是：{0:.1f}'.format(total_even))

 

• 求學生成績（列表）

# 1.輸入數據：
stu_score_s = input('請輸入您的成績（成績用逗號分隔）：')
# 2.分離數據得到數據列表：
stu_score_s_L = stu_score_s.split(",")
# print(stu_score_s_L)

# 3.讀取數據列表中的數據進行累加，求平均值
total = 0  # 初始化總分為0
score_L = len(stu_score_s_L)  # 用戶所輸入的數據列表的長度
for i in range(0, score_L):  # 遍歷數據列表中的每個數字
    total += float(stu_score_s_L[i])
    score_Avg = total / score_L
    # 4.顯示平均成績
print('您的平均成績是：{0:.1f}'.format(score_Avg))

 

• 求列表元素最大和最小值

nums = [18, 39, 11, 34, 51, 100, 69, 71, 92, 88, 5, 75]
nums.sort()
max = nums[len(nums) - 1]
min = nums[0]
print("最大值：", max)
print("最小值", min)

 

•  列表索引訪問和切片range()函數練習

 

字符串---->列表

 

 

 

 

 

 

L = input('請輸入一組奇數：').split(",")
for i in L:
    num = int(i)
    if num % 2 == 1:
        print("您輸入的數是奇數，數據為：", num)

 

 

 

元組--->列表

 

切片

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

函數形式切片

mynumlist = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
def qiepian(x, y):
    result = mynumlist[x:y]
    return print(result)


def qiepian2(x, y, z):
    result2 = mynumlist[x:y:z]
    return print(result2)


def qiepian3(x, y):
    result3 = mynumlist[x::y]
    return print(result3)


qiepian(2, 7)  # [30, 40, 50, 60, 70]
qiepian3(2, 1)  # [30, 40, 50, 60, 70, 80, 90, 100]
qiepian(0, 0)  # []
qiepian2(0, 0, 3)  # []

 range()

 

• list.sort()和簡單判斷

L = [23, 2, 6, 54, 65]
print(L)
L.sort() # 改變內容
print(L)
L.sort(reverse=True) # 反轉
print(L)

for i in L:
    if i % 2 == 0:
        print(i)
    if 89 in L:
        print(89)
else:
    print('89不存在！')

 

•  任務實現

# 使用方括號創建列表對象['pen','paper',10,False,2.5]，並賦值給變量task_tuple
task_tuple = ['pen', 'paper', 10, False, 2.5]
print(type(task_tuple))  # 查看當前變量數據類型
task_tuple = tuple(task_tuple)  # 將變量task_tuple轉換成元組類型
print(type(task_tuple))  # 查看轉換后的變量數據類型
Index = task_tuple.index(False)  # 查詢元素位置索引
bool = task_tuple[Index]  # 提取元組元素
print(bool)  # 查看提取元素

# -*- coding:utf-8 -*-
task_list = [110, 'dog', 'cat', 120, 'apple']
task_list.insert(2, [])
# task_list.pop()
task_list.remove('apple')
num_index1 = task_list.index(110)  # 查詢元素位置
num_index2 = task_list.index(120)
# print(task_list[num_index1]) #110
# print(task_list[num_index2]) #120
task_list[num_index1] *= 10  # 將查詢出來的元素進行自乘運算並賦值修改
task_list[num_index2] *= 10
print(task_list)

•  作業

# 在列表[110,’henry’,’joel’,’java’,76,’english’,89]中插入一個空列表，
# 刪除名字字符串‘joel’，同時查找表中的數值並在列表中增大1.2倍。

List = [110, 'henry', 'joel', 'java', 76, 'english', 89]
print('修改前的列表為：',List)
L_none = []
List.append(L_none)
List.remove('joel')
num_index = List.index(110)
List[num_index] *= 1.2
num_index = List.index(76)
List[num_index] *= 1.2
num_index = List.index(89)
List[num_index] *= 1.2
print('修改后的列表為：',List)

def Fibonacci(n):
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    else:
        return Fibonacci(n - 1) + Fibonacci(n - 2)


def Fibonacci_Recursion(n):
    result_list = [0, 1]
    for i in range(2, n + 1):
        result_list.append(Fibonacci(i))
    result_list.pop(2)
    list_sum = sum(result_list)
    print("列表數據之和=%d" % list_sum)
    return result_list


print("列表=%s" % Fibonacci_Recursion(5))

 

 

元組

• 元組基本操作練習

切片

 

 

 

元組--->列表

 

 

 

列表--->元組

 

 

 元組解包

 

 

 元組sorted()排序后變成列表

 

 

 其他操作

• 實訓

# 用戶自定義查詢菜單，輸出查詢結果
Str = '\n請選擇需要進行操作的對應數字：\n查詢漢堡類菜單---1\n查詢小食類菜單---2\n查詢飲料類菜單---3\n' \
      '不查詢---0：\n'
food_Type = ("漢堡類", "小食類", "飲料類")  # 索引：0,1,2
ham_Details = ("香辣雞腿堡", "勁脆雞腿堡", "新奧爾良烤雞腿堡", "半雞半蝦堡")
snacks_Details = ("薯條", "黃金雞塊", "香甜粟米棒")
drink_Details = ("可口可樂", "九珍果汁", "經典咖啡")

while True:
    print(Str)
    number = int(input())
    if number == 1:
        print(food_Type[number - 1])
        print(ham_Details)
    elif number == 2:
        print(food_Type[number - 1])
        print(snacks_Details)
    elif number == 3:
        print(food_Type[number - 1])
        print(drink_Details)
    elif number == 0:
        print("感謝您的使用！歡迎下次光臨！")
        break
    else:
        print("請輸入有效的數字編號！")

 

字典

• 基本操作

 

 

集合

• 基本操作

增：

 

 

 

 刪：

4.流程控制語句

• 輸出學生成績及獲獎等級

輸入8個成績，逗號分隔，去除最高最低成績，輸出學生成績平均值和獲獎等級

# 目標：一行輸入8個成績，去除最高和最低成績，輸出平均成績和獲獎等級
# 1.輸入數據
while True:
    try:
        score_s = input('請輸入評委給出的成績（成績用逗號分隔）：')
        score_Ls = score_s.split(',') # 字符串轉列表
        # 方法1：
        score_LI = []  # 用來保存轉換為整型的成績
        for i in score_Ls:
            score_LI.append(int(i))
        # 方法2：
        score_LI = [int(i) for i in score_Ls]  # 列表解析式[表達式 for x in iteralbeobject 條件表達式]
    except ValueError:  # 產生異常，顯示輸入數據錯誤
        print("輸入成績數據錯誤，請重新輸入！")
    else:
        # 2.數據處理
        # 2.1 在列表中刪除最大值
        max_L = max(score_LI)
        score_LI.remove(max_L)
        # 2.1 在列表中刪除最小值
        min_L = min(score_LI)
        score_LI.remove(min_L)

        # 2.3求平均值
        score_ave = sum(score_LI) / len(score_LI)
        # 2.4 根據平均值進行划分
        grade = '無獎'
        if score_ave >= 90:
            grade = '一等獎'
        elif score_ave >= 80:
            grade = '二等獎'
        elif score_ave >= 70:
            grade = '三等獎'
        elif score_ave >= 60:
            grade = '優勝獎'
        # 3.顯示結果
        print('平均成績是{:.2f}的學生的獲獎等級是：{}'.format(score_ave, grade))
        break

•  冒泡排序

# 1.用戶輸入：
mls = input("請輸入一組數據（用逗號分隔）：")
ml = [int(i) for i in mls.split(",")]  # 准備好列表數據

j = 0  # 初始化j=0，j表示第幾輪
while j < len(ml):
    count = 0  # 初始化交換器=0
    i = 0  # 初始化i=0
    while i < len(ml) - 1:
        if ml[i] > ml[i + 1]:
            ml[i], ml[i + 1] = ml[i + 1], ml[i]
            count += 1
        i += 1
    if count == 0:
        break
    j += 1
print("排序后的結果是：", ml)

 

 

•  列表解析式

a = [i ** 2 for i in range(0, 10) if i % 2 == 0]
print(a)

ml = list(map(int, input("請輸入一組數據（逗號分隔）：").split(",")))
print(ml)

 

•  判斷素數

# 編程：判斷輸入的一個數是否是素數（質數），不是素數則循環，輸出素數則停止循環
# 只能被自己和1整除的數
while True:
    num = int(input("請輸入一個整數：（大於1）"))
    if num == 0:
        exit(0)
    isPriss = True
    count = 0
    for i in range(2, num // 2 + 1):  # 迭代要去除的數
        # count += 1
        if num % i == 0:
            print("{}不是質數，{}={}*{}".format(num, num, i, num // i))
            isPriss = False
    # 退出for代碼，有兩種可能，一種是迭代結束，是質數，一種break跳出for
    if isPriss:
        print("{}是質數".format(num))
        break
    # print("count=", count)

•  判斷素數2

# 編程：判斷輸入的一個數是否是素數（質數）
# 只能被自己和1整除的數
num = (input("請輸入一組整數：數字大於1，數字間用逗號隔開："))
num_L = [int(i) for i in num.split(",")]
for num in num_L:  # num從輸入的數據列表中取得的一個數
    # 判斷num是否是一個質數
    isPriss = True
    # count = 0
    for i in range(2, num // 2 + 1):  # 迭代要去除的數
        # count += 1
        if num % i == 0:
            print("{}不是質數×，{}={}*{}".format(num, num, i, num // i))
            isPriss = False
            break
    # 退出for代碼，有兩種可能，一種是迭代結束，是質數，一種break跳出for
    if isPriss:
        print("{}是質數√".format(num))

 

•  回文數

# 目標：輸入一個正整數；輸出：M位的回文數共有幾個，這些回文數中有幾個包含數字99
# 1.構造M位數的列表
# 1.1用戶輸入位數M
m = int(input('請輸入一個正整數：'))

# 1.2構造m位的列表
m_L = list(range(10 ** (m - 1), 10 ** m))

# 2.找有多少個回文數？包含99的多少個
count_HW = 0
count_99HW = 0
for i in m_L:
    # 判斷i是否是回文數
    s = str(i)  # 將整型數據轉換為字符類型
    if s == s[::-1]:
        count_HW += 1
        print("s:", s)
        if s.find('99') != -1:  # 在回文數中找是否存在99這個數字
            count_99HW += 1
# 3.顯示結果：
print("{}位的數字列表中回文數是{}個，包含'99‘的有{}個".format(m, count_HW, count_99HW))

 

•  折半查找

# 折半查找
# L=[34,57,68,78,78,101,106],N=45or57,返回57所在的索引號

# L_index=[0,1,2,3,4,5,6]
# 1.數據准備
import random

L = []
for i in range(0, 10):
    L.append(random.randint(0, 100))
L.sort()
print(L)
# 2.折半查找
max_index = len(L) - 1
min_index = 0
# 用戶輸入數據
N = int(input("請輸入要查找的數據："))
while True:
    if max_index >= min_index:
        # 查找
        # 用戶查找數據
        i = (max_index + min_index) // 2
        if N == L[i]:
            print("找到{0},它的索引號為{1}".format(N, i))
            break
        elif N > L[i]:
            min_index = i + 1
        else:
            max_index = i - 1
    else:
        # index=-1 #表示沒有找到
        print("沒有找到{}".format(N))
        break

•  數字金字塔

# 1.用戶數字金字塔的層數
num = eval(input("請輸入一個整數："))
print(num)
# 2.顯示數字金字塔
# 2.0初始化變量
level = 1
# 2.1 循環輸出N層數字
while level <= num:
    # 2.1.1輸出第level層數字，level是從1到N
    kk = 1  # 表示的每一層開始顯示的時候是第幾個數
    t = level  # 表示輸出第幾個層
    length = 2 * t - 1  # 表示每一層的數字的總長度
    # 顯示第t層的數字
    while kk <= length:  # 顯示的數字個數
        if kk == 1:  # 表示第一個數字
            if kk == length:  # 表示第1層數字也表示最后一個數字
                print(format(t, str(2 * num - 1) + "d"), "\n")
                break
            else:  # kk是第一數，但是 不是最后一個的
                print(format(t, str(2 * (num - level) + 1) + "d"), '', end=" ")
                t = -1  # 要顯示的下一個數
        else:  # 其他位置的數字的處理
            if kk == length:
                print(t, '\n')
            elif kk <= length / 2:
                print(t, "", end="")
                t -= 1
            else:
                print(t, "", end="")
                t += 1
        kk += 1
    level += 1

 

•  猜數字游戲

此題有bug，計數器沒設置好。

import random


def GuessNumber():
    # 編程，實現猜數字游戲
    # 1.產生隨機數
    number = random.randint(0, 100)
    # 2.猜數字
    guess = 0  # 保存猜的次數
    # 循環猜的過程，退出的循環的條件？猜到了退出，或者猜到6次的時候退出
    max_Num = 100  # 上限
    min_Num = 0  # 下限
    while guess <= 6:
        # 2.1 用戶輸入猜的數字
        try:
            guess_Num = int(input('請輸入您要猜的數字({0}-{1})：'.format(min_Num, max_Num)))
            # 2.2 判斷猜的數字大小正確三種可能性
            guess += 1  # 計數加1
            if guess_Num == number:
                print('恭喜您，您猜對了！')
                break
            elif guess_Num > number:
                print('您猜大了！您還可以猜{}次！'.format(6 - guess))
                max_Num = guess_Num
            elif guess_Num < number:
                print('您猜小了！您還可以猜{}次！'.format(6 - guess))
                min_Num = guess_Num
            else:
                print('輸入的數據有誤！您還可以猜{}次！'.format(6 - guess))
        except Exception as e:
            print(e)


if __name__ == '__main__':
    GuessNumber()

 

•  新年倒計時

num = 60
# 顯示60，59，...0：顯示數字，數字遞減
print('新年到了咱們一起倒數吧！')
while num >= 0:
    # print(num)
    print('倒計時{}秒'.format(num))
    num -= 1

print('新年快樂！')

 

 

 

•  數字連加和連乘

# 1.創建1~10的自然數列表
sum_L = 0  # 連加初始為0
mul_L = 1  # 連乘初始為0
for i in range(1, 11):
    sum_L += i
    mul_L *= i
# 2.輸出結果
print('1-10連加的結果是{},連乘的結果是{}'.format(sum_L, mul_L))

•  九九乘法表

#九九乘法表
for x in range(1,10):
    for y in range(1,x+1):
        print(f'{x}*{y}={x*y}',end='\t')
    print('\r')

 

•  成績判斷

# 判斷成績為優秀、良好和不及格
print("----成績判斷----")
# 1.用戶輸入數據：
while True:
    score = float(input("請輸入您的成績："))
    # 2.if ..elif..else判斷
    if score >= 90:
        print("您的成績是%.2f，經鑒定，為A級！\n" % score)

    elif score >= 80 and score < 90:
        print("您的成績是%.2f，經鑒定，為B級！\n" % score)
    elif score >= 70 and score < 80:
        print("您的成績是%.2f，經鑒定，為C級！\n" % score)
    elif score >= 60 and score < 70:
        print("您的成績是%.2f，經鑒定，為D級！\n" % score)
    else:
        print("您的成績是%.2f,經鑒定，為不及格的E級！請再接再厲！\n" % score)
        break

 

•  1-100的和

# 計算1~100之間所有整數的和
sum = 0
for i in range(1, 101):
    sum += i
    # sum = sum + i 等同於上面的寫法
print(sum)

5.函數

• 全局變量與局部變量

'''
總結：
 1.全局變量如果要在函數中被引用，則需要使用global對其進行聲明，並且沒有同名的局部變量
 2.局部變量只能在函數中被引用，函數外不可見
 3.局部變量和全局變量同名，函數是無法引用全局變量
'''
sum1 = 0


def sum_x(x):  # 函數
    # sum1=0 #局部變量
    sum1 = 2  # 如果局部變量和全局變量名字一致，會出錯，用global聲明全局變量
    # global sum1  #說明sum1是一個全局變量
    print("sum1=", sum1)
    for i in x:
        sum1 += i
    return sum1


print(sum_x([2, 4]), "sum1=", sum1)

• 自定義函數並導入

# steak.py
def make_steak(d, *other):
    print("Make a steak well done in %d" % d + "with the other:")
    for o in other:
        print("-" + o)


def pay(money):
    balance = 100
    return balance

#CollApp.py
from steak import *

make_steak(8, "red mine")
print("卡里的余額是：", pay(120))

•  數值運算

def add(x, y):  # def函數定義關鍵字，add函數名稱，x,y參數
    return x + y  # 返回表達式的計算結果


def sum_L(x_L):  # 求和
    total = 0
    for i in x_L:
        total += i
    # 對列表x_L求和，結果保存在total
    return total


def ave_L(x_L):  # 求均值
    total = 0
    for i in x_L:
        total += i
    return total / len(x_L)


def sum_2L(x_L):  # 求平方和
    total = 0
    for i in x_L:
        total += i ** 2
    return total


if __name__ == '__main__':  # 把運行的語句放到main函數中，否則其他文件代碼用此文件的函數用完后，還會繼續往下執行！
    result1 = add(3, 4)  # 調用函數add進行兩個數的加法運算
    print(result1)
    result2 = sum_L([1, 2, 3])
    result3 = ave_L([1, 2, 3])
    result4 = sum_2L([1, 2, 3])
    print("[1, 2, 3]：\n總和為：{}\n均值為：{}\n平方和為:{}".format(result2, result3, result4))

from ch05.Demo.MyDef import ave_L as al


# 定義求方差的函數，並調用該函數完成方差求解
# 調用函數求給定的任意數的方差（可變數量的參數調用）

def fc(*args):  # 可變參數args獲取的是元組類型
    m = len(args)  # 元組的長度
    ave = al(args)
    total = 0
    for i in args:
        total += (i - ave) ** 2
    return total / m


print(fc(1, 2, 3))

 

from ch05.Demo.MyDef import ave_L as al  # 取別名為al


# 定義函數求輸入學生的平均成績，並顯示每個科目的成績


def ave_Student(**kwargs):
    value = list(kwargs.values())  # 獲得成績的數據
    ave_value = al(value)  # 調用自定義函數ave_L求平均值
    return ave_value
    # return ave_L(value)


result = ave_Student(Java=98, math=99, english=100)
print(result)

• map函數

# map(function,list):參數，返回結果：map對象
def add(x, y):
    return x ** 2 + y ** 2


print(list(map(add, [3, 4], [3, 4])))

 

def add(x):
    return x**3
numbers = list(range(1,20,2))
# num1 = list(map(add,numbers))
num2 = list(map(lambda x:x+3,numbers))
print(numbers)
# print(num1)
print(num2)

•  過濾出1-100中平方根是整數的數

import math


# filter
# 過濾出1-100中平方根是整數的數

def is_sqr(x):
    return math.sqrt(x) % 1 == 0


newlist = filter(is_sqr, range(1, 101))
print(list(newlist))

# lambda
numbers = list(range(1, 101))
newlist2 = list(filter(lambda x: math.sqrt(x) % 1 == 0, numbers))#

print(newlist2)

•  漢諾塔

def hlt(n,a,b,c):
    if n ==1:
        print("{}->{}".format(a,c))

    elif n>1:
        hlt(n-1,a,b,c)
        print("{}->{}".format(a,c))
        hlt(n-1,b,a,c)

hlt(3,"A塔","B塔","C塔")

 

•  函數遞歸

# 遞歸函數:特性：1.具有相似性，fib(10)和計算fib(9) 2.解決問題，規模在縮減，最后能夠返回具體的數
# 斐波那契數列
def fib(n):
    if n == 1:
        return 0
    elif n == 2:
        return 1
    elif n > 2:
        return fib(n - 1) + fib(n - 2)  # 在函數中調用函數本身，遞歸
    else:
        print("輸入的數據有誤！")


print(fib(3))


# 求階乘
def mul(n):  # mul返回n的階乘
    if n == 0:
        return 1
    elif n > 0:
        return n * mul(n - 1)  # n!=n*(n-1)! 即：1x2x3...x(n-1)*n
    else:
        return -1  # 若輸入有誤，返回-1


print(mul(5))


def sum(n):
    if n == 0:
        return 0
    if n >= 1 and n <= 100:
        return n + sum(n - 1)
    else:
        print("輸入的數據超出了范圍！")


print(sum(5))

 

•  漢諾塔問題

i = 1


def move(n, mfrom, mto):
    global i
    print("第%d步:將%d號盤子從%s -> %s" % (i, n, mfrom, mto))
    i += 1


def hanoi(n, A, B, C):
    if n == 1:
        move(1, A, C)
    else:
        hanoi(n - 1, A, C, B)
        move(n, A, C)
        hanoi(n - 1, B, A, C)


print("移動步驟如下：")
hanoi(3, 'A', 'B', 'C')

 

•  定義一個求列表中位數的函數

# 構建一個計算列表中位數的函數

def median(*args):
    data = sorted(*args)
    data_len = len(data)
    print("排序后的列表為：", data)
    if (data_len % 2 == 0):
        result = (data[int(data_len / 2)] + data[int(data_len / 2 - 1)]) / 2
        print("該列表有{0}個數字，長度是偶數,中位數為{1}".format(int(data_len), result))
    else:
        result = data[int(data_len / 2)]
        print("該列表有{0}個數字，長度是奇數,中位數為{1}".format(int(data_len), result))


median([2, 1, 6, 4, 10, 8, 9, 10])
print("\n")
median([2, 1, 6, 4, 10, 8, 9, 10, 25, 80, 8])

6.面向對象編程

• Car類

# Car.py
class Car:
    wheelNum = 4
    color = 'red'

    def getCarInfo(self, name):
        self.name = name
        print(self.name, '有%d個車輪，顏色是%s' % (self.wheelNum, self.color))

    def run(self):
        print("車行駛在學習的大道上")

    def hideself(self):
        print("現在隱身")


car1 = Car()
car1.getCarInfo('Land Rover')
car1.run()
car1.hideself()

•  Cat類

# 類成員變量:訪問類成員變量：類名.變量名   #訪問實例成員變量：self.成員變量名
class Cat():
    name = "貓"  # 類成員變量
    age = 3

    def __init__(self):
        self.name = "kitty"

    def __init__(self, name, age):  # 構造方法,初始化數據 # 局部變量
        self.__name = name  # 實例對象的成員變量
        self.__age = age  # 利用__將實例變量私有化

    def __getName(self):  # 私有方法不能在類定義之外的地方被調用
        return self.name

    # def __del__(self):  # 刪除
    #     print("析構方法被調用")

    def sleep(self):  # self當前對象，this
        print("%d歲的%s正在陽台睡覺" % (self.__age, self.__name))

    def eat(self, food):
        self.food = food  # food 局部變量，self.food成員變量  this.name=name
        print("%d歲的%s正在吃%s" % (self.__age, self.__name, self.food))


cat1 = Cat("嘟嘟", 2)
cat1.sleep()
cat1.eat("fish")

cat2 = Cat("土豆", 5)
cat2.name = "小王"
cat2.eat("rice")
del cat2
# cat2.eat("rice") NameError: name 'cat2' is not defined
print(Cat.name)

 

# 類成員變量:訪問類成員變量：類名.變量名   #訪問實例成員變量：self.成員變量名
class Cat():
    name = "kitty"  # 類成員變量
    age = 3

    def __init__(self, name, age):  # 構造方法,初始化數據 # 局部變量
        self.name = name  # 實例對象的成員變量
        self.age = age
        self.info = [self.name, self.age]
        self.index = -1

    def __iter__(self):
        print("名字 年齡")
        return self

    def next(self):  # 取出屬性
        if self.index == len(self.info) - 1:
            raise StopIteration
        self.index += 1
        return self.info[self.index]

    def __del__(self):  # 刪除
        print("析構方法被調用")

    def sleep(self):  # self當前對象，this
        print("%d歲的%s正在陽台睡覺" % (self.age, self.name))

    def eat(self, food):
        self.food = food  # food 局部變量，self.food成員變量  this.name=name
        print("%d歲的%s正在吃%s" % (self.age, self.name, self.food))


cat1 = Cat("嘟嘟", 2)
cat1.sleep()
itor = iter(cat1.next, 1)
for info in itor:
    print(info)

 

 

 

•  繼承

class Cat():  #
    def __init__(self):
        self.name = '貓'
        self.age = 4
        self.info = [self.name, self.age]
        self.index = -1

    def run(self):
        print(self.name, "--在跑")

    def getName(self):
        return self.name

    def getAge(self):
        return self.age

    def __iter__(self):
        print("名字 年齡")
        return self

    def next(self):
        if self.index == len(self.info) - 1:
            raise StopIteration
        self.index += 1
        return self.info[self.index]


class Bosi(Cat):
    def setName(self, newName):
        self.name = newName

    def eat(self):
        print(self.name, '--在吃')


bs = Bosi()
print("bs的名字為：", bs.name)
print("bs的年齡為：", bs.age)
bs.run()

bs.setName("波斯貓")
bs.eat()

interator = iter(bs.next, 1)

for info in interator:
    print(info)

7.文件基礎

• 列表求和

file_name = "../data/score.txt"
with open(file_name, mode="r", encoding="utf-8") as f:
    text = f.read()
    text_L = [float(x) for x in text.split("\n")]  # 以\n為分隔,遍歷出text中的數據
    print(text_L, type(text_L))
    print(text_L, sum(text_L))

 

file_name = "../data/score.txt"
with open(file_name, mode="r", encoding="utf-8") as f:
    text = f.readlines()
    print(text, type(text))  # readlines:按行讀所有， 讀出來的直接就是list
    text_L = [float(x.rstrip()) for x in text]  # 遍歷出text中的數據保存在x中，並用rstrip去掉末尾字符，最后轉換為float型
    print(text_L)
    print(sum(text_L))

 

 

 

readline

file_name = "../data/score.txt"
with open(file_name, mode="r", encoding="utf-8") as f:
    text = f.readline()
    print(text, type(text))

 

 

•  讀寫文件

file_name = "../data/score.txt"
with open(file_name, mode="r", encoding="utf-8") as f:
    text = f.read()
    text_L = [float(x) for x in text.split("\n")]  # 以\n為分隔,遍歷出text中的數據
    print(text_L, type(text_L))
    Sum=sum(text_L)
    print("數據是:{},累加結果是:{}".format(text_L, Sum))

with open(file_name, mode="a", encoding="utf-8") as f:
    f.write("\n總共是:{}".format(Sum))
    print("寫入成功！")
    f.close()

• 讀

try:
    f = open("../data/Student.txt", mode="r")
    txt = f.read()
    f.close()
except:
    print("找不到文件!")
else:
    print(txt, type(txt))
# finally:
#     if f:
#         f.close()

print("\n")

try:
    with open("../data/Student.txt", mode="r") as f:
        print(f.read())
except:
    print("找不到文件!")

 

 

 

 

try:
    with open("../data/Singer.txt", mode="r", encoding="utf-8")as f:
        text = f.read()
        # print(text)
        print("”音樂“在新聞片段中出現的次數:", text.count("音樂"))
except:
    print("找不到文件!")

 

 

 

try:
    f = open("../data/e_ point.txt", "r")
    print(f.read())
finally:
    if f:
        f.close()

print("\n")

with open("../data/e_ point.txt", "r") as f:
    print(f.read())
    f.close()

 

 

 

file_name = '../data/e_ point.txt'
with open(file_name, "r")as f:
    for line_t in f:
        print(line_t)

 

 

 

去掉換行符：

file_name = "../data/e_ point.txt"
with open(file_name, "r") as f:
    for line_t in f:
        print(line_t.rstrip())

 

 

 

read 返回字符串

with open("../data/e_ point.txt") as f:
    txts = f.read()
print(type(txts))

print(txts)

 

 

 

 readlines 返回列表：

with open("../data/e_ point.txt") as f:
    txts = f.readlines()
print(type(txts))
print(txts)

 

 

 

readlines讀取后，遍歷並去除換行符輸出

with open("../data/e_ point.txt") as f:
    txts=f.readlines()
for txt in txts:
    print(txt.strip())

 

 

 

readline 返回字符串

with open("../data/e_ point.txt")as f:
    txt = f.readline()
print(type(txt))
print(txt)

 

 

 

• 寫

file_name = "../data/words.txt"
f = open(file_name, "w")
f.write("Hello,world!")
f.close()

 

file_name = "../data/data.txt"
f = open(file_name, "w")
data = list(range(1, 11))
# f.write(data)  #TypeError: write() argument must be str, not list
f.write(str(data))
f.close()

 

 

**：以下words.txt 每次運行完，自己手動刪除了所有數據后，再測試。

file_name = "../data/words.txt"
f = open(file_name, "w")
f.write("Hello,world!\n")
f.write("I love Python!\n")
f.close()

 

 

 

file_name = "../data/words.txt"
with open(file_name, "w",encoding="gbk")as f:
    f.write("Hello,world!\n")
    f.write("I love Python!\n")

 

 

 

file_name = "../data/words.txt"
with open(file_name, "a")as f:
    f.write("What's your favourite language?\n")
    f.write("My favourite language is Python!\n")

 

 

•  讀寫CSV文件

• 讀

csv.reader()

csv.Dictreader()

鳶尾花數據集

import csv

file_name = "../data/iris.csv"  # csv是文本文件
with open(file_name, "r") as f:
    reader = csv.reader(f)
    # print(reader,type(reader))
    # #直接打印reader:<_csv.reader object at 0x000001E8AF492520>  類型： <class '_csv.reader'> 是一個reader對象
    iris = [iris_item for iris_item in reader]
print(iris)
print(type(iris))

 

 

 

import csv

file_name = "../data/iris.csv"
with open(file_name, "r") as f:
    reader = csv.DictReader(f)
    # print(reader,type(reader)) # <csv.DictReader object at 0x000001CBAA89F0A0> <class 'csv.DictReader'>
    iris = [iris_item for iris_item in reader]
print(iris)

import csv

file_name = "../data/iris.csv"
with open(file_name, "r") as f:
    reader = csv.DictReader(f)
    column = [iris_item["Sepal.Length"] for iris_item in reader]
print(column)

 

 

 

•  寫

import csv

file_name = "../data/iris.csv"  # csv是文本文件
with open(file_name, "r") as f:
    reader = csv.reader(f)
    # print(reader,type(reader))
    # #直接打印reader:<_csv.reader object at 0x000001E8AF492520>  類型： <class '_csv.reader'> 是一個reader對象
    iris = [iris_item for iris_item in reader]

file_name = "../data/test.csv"

with open(file_name, "w", newline='')as f:
    write_csv = csv.writer(f)
    write_csv.writerow(iris)

 

 

import csv

file_name = "../data/iris.csv"
with open(file_name, "r") as f:
    reader = csv.DictReader(f)
    iris = [iris_item for iris_item in reader]

file_name2 = "../data/test2.csv"
my_key = []  # 鍵的集合
for i in iris[0].keys():
    my_key.append(i)

with open(file_name2, "w", newline='')as f:
    write_csv = csv.DictWriter(f, my_key)
    write_csv.writeheader()  # 輸入標題
    write_csv.writerows(iris)  # 輸入數據

 

 

 

•  將1-100的平方和寫入文件

squares = [value ** 2 for value in range(1, 101)]
import csv

file_name = "../data/squares.csv"
with open(file_name, "w", newline='')as f:
    write_csv = csv.writer(f)
    for square in squares:
        write_csv.writerows([str(square)])

 

 

•  讀取學生成績，求平均成績

 

import csv

# 構建學生成績的csv文件，從文件中讀取數據，顯示學號為2
file_name = "../data/學生成績.csv"  # csv是文本文件
N = "2"  # 學號是2
with open(file_name, "r") as f:
    reader = csv.reader(f)
    score = [scores_item for scores_item in reader]
    for i in score:
        if i[0] == N:
            print(i)
            print("學號為：", i[0])
            break
    else:
        print("{}學號不存在".format(N))

    python_l = [float(score[i][2]) for i in range(1, len(score))]  # 索引1到索引3有成績數據，索引0是標題，所以從索引1開始
    # score[i][2] 是成績
    python_ave = sum(python_l) / len(python_l)
    print("平均成績是：{}".format(python_ave))
print(score)
# [['學號', '姓名', 'Python'], ['1', 'henry', '87'], ['2', 'David', '98'], ['3', 'Alice', '67']]

 

 

 

只算Python鍵的值的平均值：

import csv

# DictReader 保存字典形式
file_name = "../data/學生成績.csv"
N = "2"  # 學號是2
with open(file_name, "r") as f:
    reader = csv.DictReader(f)
    datas = [float(datas_item["Python"]) for datas_item in reader]
    # print(datas) # python 中這個列的成績數據：['87','98','67']
    print(sum(datas) / len(datas))

 

csv.reader()讀取；csv.writer()寫入

import csv

filename = "../data/學生成績.csv"
with open(filename, "r")as f:
    reader = csv.reader(f)
    datas = [datas_item for datas_item in reader]
    print(datas)

# 寫文件
filename_w = "../data/學生成績副本.csv"
with open(filename_w, "w") as f:
    writer_csv = csv.writer(f)
    writer_csv.writerows(datas)

 

csv.DictReader()讀取;csv.DictWriter()寫入

import csv

filename = "../data/學生成績.csv"
with open(filename, "r") as f:
    reader = csv.DictReader(f)
    datasL = [datas_item for datas_item in reader]
    print(datasL)
mykeys = [i for i in datasL[0].keys()]

# 寫文件方法二：
filename_w = "../data/成績信息副本.csv"
with open(filename_w, "w", newline='') as f:
    writer_csv = csv.DictWriter(f, mykeys)
    writer_csv.writeheader()
    writer_csv.writerows(datasL)