Python语法2

选择结构
循环结构
文件读写
函数
类和对象

选择结构

if，elif，else，使用时注意条件的先后顺序

通过缩进四个空格来区分代码块

# 从控制台输入

age = int(input("请输入一个年龄"))

if age >= 18:

    print("成年")

elif age < 0:

    print("输入错误")

else:

    print("未成年")

循环结构

for，whil，如果做循环一般使用while，for循环一般用于遍历

# 计算1-100和的值

i = 0

cum = 0

while i < 100:

    i += 1

    # 在Python没有++，--方法

    cum += i

print(cum)

# 计算10的阶乘

cum = 1

i = 1

while i < 10:

    cum = cum * i

    i = i + 1

print(cum)

# 直接遍历字典只能获取key

dict1 = {"k1": "v1", "k2": "v2", "k3": "v3"}

for key in dict1:

    print(key)

# 获取value

for key in dict1:

    print(key, dict1.get(key))

# 使用items方法，返回二元组类型

for i in dict1.items():

    print(i, type(i))

# 用两个变量进行接收二元组

for i, j in dict1.items():

    print(i, j)

5050

362880

k1

k2

k3

k1 v1

k2 v2

k3 v3

('k1', 'v1') <class 'tuple'>

('k2', 'v2') <class 'tuple'>

('k3', 'v3') <class 'tuple'>

k1 v1

k2 v2

k3 v3

文件读写

# 读文件

f1 = open("data/data1", mode="r", encoding="utf8")

# mode="r", encoding="utf8"也可以省略

print(f1.read(10))  # 读取指定字符个数

print(f1.readline())  # 读取一行

print(f1.readlines())  # 读取所有行，并以list存储

f1.close()

# 写文件

f2 = open("data/write1", mode="w")

# w表示写文件覆盖写，a表示追加写

# write只能写string

f2.write("1\n")

# writelines可以写列表

f2.writelines(["1", "2", "3"])

f2.close()

# 读写文件

# 每次读写都需要close关闭，所以可以用with open，可以自动关闭

with open("data/data1") as f1:

    with open("data/write2", mode="w") as f2:

        f2.writelines(f1.readlines())

D:\ALanzhishujia\soft\python\python.exe C:/Users/19768/PycharmProjects/PythonLearning/demo3.py

Beautiful

is better than ugly.

['Explicit is better than implicit.\n', 'Simple is better than complex.\n', 'Complex is better than complicated.\n', 'Flat is better than nested.\n', 'Sparse is better than dense.\n', 'Readability counts.\n', "Special cases aren't special enough to break the rules.\n", 'Although practicality beats purity.\n', 'Errors should never pass silently.\n', 'Unless explicitly silenced.\n', 'In the face of ambiguity, refuse the temptation to guess.\n', 'There should be one-- and preferably only one --obvious way to do it.\n', "Although that way may not be obvious at first unless you're Dutch.\n", 'Now is better than never.\n', 'Although never is often better than *right* now.\n', "If the implementation is hard to explain, it's a bad idea.\n", 'If the implementation is easy to explain, it may be a good idea.\n', "Namespaces are one honking great idea -- let's do more of those!\n"]

函数

# 计算圆的面积

def area_of_cycle(r):

    pi = 3.14

    print(pi * r * r)

area_of_cycle(2)

# 计算1-n的和

def sum_1_to_n(n):

    cum = 0

    i = 1

    while i < n + 1:

        cum = cum + i

        i = i + 1

    print(cum)

sum_1_to_n(10)

# 计算1-n的阶乘

def jieCheng(n):

    i = 1

    cum = 1

    while i <= n:

        cum = cum * i

        i = i + 1

    print(cum)

jieCheng(10)

# 递归实现阶乘

def recursion(n):

    if n == 1:

        return 1

    return n * recursion(n - 1)

print(recursion(10))

# 计算x的n次方

def power(x, n):

    print(x ** n)

power(2, 3)

# 传入大量的数求和，可以传入list中

list1 = [i for i in range(1, 101)]

def sum_nums_with_list(l):

    cum = 0

    for i in l:

        cum += i

    print(cum)

sum_nums_with_list(list1)

# 可变参数 *，可以不用list直接传入数

# args相当于一个list

def sum_nums_with_args(*args):

    cum = 0

    for i in args:

        cum += i

    print(cum)

sum_nums_with_args(1, 2, 3, 4, 5)

# 等价于

list2 = [1, 2, 3, 4, 5]

sum_nums_with_args(list2[0], list2[1], list2[2], list2[3], list2[4])

sum_nums_with_args(*list2)

# 关键字参数**

# **后的参数相当于传入的值进入一个字典

def regsiter(name, age, address, phone, **kw):

    dict1 = {"name": name, "age": age, "address": address, "phone": phone, "others": kw}

    print(dict1)

regsiter("张三", "18", "合肥", "139")

regsiter("张三", "18", "合肥", "139", year="2021", month="10")

# 命名关键字参数

# 检查传入参数是否有year，month

def regsiter2(name, age, address, phone, **kw):

    if "year" in kw.keys():

        print("year")

    if "month" in kw.keys():

        print("month")

    dict1 = {"name": name, "age": age, "address": address, "phone": phone, "others": kw}

    print(dict1)

regsiter2("张三", "18", "合肥", "139", year="2021", month="10")

# 匿名函数

# 对list中每一个元素进行平方

list3 = [1, 2, 3]

def func(x):

    return x * x

print(list(map(func, list3)))

# 因为要写一个函数太过函索，所以可以使用lambda简化

print(list((map(lambda x: x ** x, list3))))

结果：

类和对象

类是对象抽象，对象时类的具体实现

三大特性：封装，继承，多态

# 定义一个Person类

# 封装：类里面封装属性，方法

class Person():

    # 定义一个构造方法

    # 类的属性需要定义在构造方法中

    # 类中所有得方法第一个参数都是self，在调用时会自动转入

    def __init__(self, id, name, age, gender):

        self.id = id

        self.name = name

        self.age = age

        self.gender = gender

        # 这个属性不需要通过传参，直接写死

        self.common = "我是猪"

        # 如果某个属性不想公开，可以在属性之前加上__

        self.__secret = "这是一个秘密"

    # 定义方法

    def run(self):

        print("%s 跑的很快" % (self.name))

        return 1

    # 相当于java中的tostring

    def __str__(self):

        return "class Person(%d %s %d %s)" % (self.id, self.name, self.age, self.gender)

    # 封装方法

    def __test(self):

        print("测试封装方法")

# 实例化 构造对象

person = Person(1001, "张三", 18, "男")

print(person)

print(person.name)

print(person.run())

# 调用封装的属性，通过 _类型__属性名 获取

print(person._Person__secret)

# 调用封装的方法

person._Person__test()

print("----------------------------------------------")

# 继承

class Teacher(Person):

    def __init__(self, id, name, age, gender, subject):

        # 直接得到父类的属性

        super(Teacher, self).__init__(id, name, age, gender)

        self.subject = subject

    # 写个teach的方法

    def teach(self):

        print("%s教的%s很棒" % (self.name, self.subject))

    # 重写Person的tostring方法

    def __str__(self):

        return "class Teacher:%d %s %d %s %s" % (self.id, self.name, self.age, self.gender, self.subject)

teacher = Teacher(1002, "张老师", 33, "女", "语文")

print(teacher)

print(teacher.name)

# 这里可以直接使用父类的方法

print(teacher.run())

print(teacher.teach())

print("---------------------------------")

# 多态

# 父类引用指向子类对象

def runTwice(c):

    c.run()

    c.run()

runTwice(person)

runTwice(teacher)

结果：

巴特西

Python语法2

选择结构

循环结构

文件读写

函数

类和对象

最新文章

热门文章