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)