Python基础笔记

• python的应用场景
• web应用开发
• 操作系统管理.服务器的运维自动化脚本
• 科学计算
• 桌面软件
• 服务器软件
• 游戏

注释

python的单行注释  :#
python的多行的注释  : """ """

变量

# 程序用来处理数据的,而且就是用来存储数据
name = 100 

 

标识符和关键字

标识符:由字母.下划线.和数字.而且不能开头
关键字:具有特殊功能的标识符,如:and  as
命名规则:
小驼峰:第一个单词以小字母开始,第二个单词用大写
大驼峰:每个单词都是大写字母

输出

print("我是输出哦")

输入

name = input("我是输入哦")

常用格式化符号

%s :通过str()字符串来格式化
%d :整数
%f :浮点实数
%c :字符

%i :有符号的十进制
%u :无符号的十进制
%o :八进制
%X :十六进制(大写字母)
%G : ％f和％E的简写
%E :索引符号（大写“E”）
%e :索引符号（小写'e'）

运算符

+:加    两个对象相加 a + b 输出结果 30
-:减    得到负数或是一个数减去另一个数 a - b 输出结果 -10
*:乘    两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
/:除    x除以y b / a 输出结果 2
//:取整除    返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
%:取余    返回除法的余数 b % a 输出结果 0
**:幂    返回x的y次幂 a**b 为10的20次方

复合运算符

+=:加法赋值运算符    c += a 等效于 c = c + a
-=:减法赋值运算符    c -= a 等效于 c = c - a
*=:乘法赋值运算符    c *= a 等效于 c = c * a
/=:除法赋值运算符    c /= a 等效于 c = c / a
%=:取模赋值运算符    c %= a 等效于 c = c % a
**=:幂赋值运算符    c **= a 等效于 c = c ** a
//=:取整除赋值运算符    c //= a 等效于 c = c // a

比较运算符

==  :检查两个操作数的值是否相等，如果是则条件变为真。
!=   :检查两个操作数的值是否相等，如果值不相等，则条件变为真。
<>  :检查两个操作数的值是否相等，如果值不相等，则条件变为真。
>    :检查左操作数的值是否大于右操作数的值，如果是，则条件成立。
<    :检查左操作数的值是否小于右操作数的值，如果是，则条件成立。
>=  :检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。    
<=  :检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。    

逻辑运算符

and    : x and y    布尔"与" - 如果 x 为 False，x and y 返回 False
or    : x or y    布尔"或" - 如果 x 是 True，它返回 True
not    : not x    布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False

数据类型的转换

int(x [,base ])    :将x转换为一个整数
long(x [,base ]) :将x转换为一个长整数
float(x )            :将x转换到一个浮点数
complex(real [,imag ]) :    创建一个复数
str(x )    :将对象 x 转换为字符串
repr(x )    :将对象 x 转换为表达式字符串
eval(str )    :用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s )    :将序列 s 转换为一个元组
list(s )    :将序列 s 转换为一个列表
chr(x )    :将一个整数转换为一个字符
unichr(x )    :将一个整数转换为Unicode字符
ord(x )    :将一个字符转换为它的整数值
hex(x )    :将一个整数转换为一个十六进制字符串
oct(x )    :将一个整数转换为一个八进制字符串

循环的使用

n = input("请输入你要选择的数字")
if n== "4":
    print("今天是星期四")
else:
    print("今天不是星期四")

 

while循环嵌套的使用

# 九九乘法表 
   i = 1
    while i<=9:
        j=1
        while j<=i:
            print("%d*%d=%-2d "%(j,i,i*j),end='')
            j+=1
        print('\n')
        i+=1

break和continue的使用

# break/continue只能用在循环中，除此以外不能单独使用
# break　用来结束整个循环
n = 1
i =1
while i < 10:
    n += i
    i += 1
    if i == 3:
        break
print(n)
# 输出结果　４


# continue 用来结束本次循环，紧接着执行下一次的循环

a = 1
b = 1
while a < 10:
    b += a
    a += 1
    if a == 3:
        continue
print(b)   
# 输出结果　４６

 字符串的切片

name = 'shendinggai'
# 左闭右开  步长默认为１
print(name[1:3])  
# 结果为:he

print(name[0:len(name)])
# 结果为:shendinggai

print(name[1:-1])
# 结果为:hendingga

print(name[::-2])
# 结果为:igndes

print(name[::-1])
# 结果为:iaggnidnehs

 字符串的常见操作

# find 的使用  异常返回－１
mystr = 'hello python hello pythonWorld'

print(mystr.find("python", 0, len(mystr)))
# 结果为:6

# index 的使用　　　异常会报错
print(mystr.index("python", 0, len(mystr)))
# 结果为:6

# count 的使用　计算个数
print(mystr.count("python", 0, len(mystr)))
# 结果为:2

# replace中的替换
print(mystr.replace("python", "shendinggai", mystr.count("itcast")))
# 结果为:hello python hello pythonWorld

# split 为分割   后面带分割数量
print(mystr.split(" ", 9))
# 结果为:['hello', 'python', 'hello', 'pythonWorld']

# capitalize  把字符串的第一个字符大写
print(mystr.capitalize())
# 结果为:Hello python hello pythonworld

# title 把每个首字母大写
print(mystr.title())
# 结果为:Hello Python Hello Pythonworld

# startwith 检查是否以hello开头,返回bool值
print(mystr.startswith("hello"))
# 结果为:True

# endswith　检查是否以world结束
print(mystr.endswith("world"))
# 结果为:False

# mystr中的所有大写转换为小写字符
print(mystr.lower())
# 结果为:hello python hello pythonworld

# upper　转换mystr的小写字母为大写
print(mystr.upper())
# 结果为:HELLO PYTHON HELLO PYTHONWORLD

# ljust 返回一个原字符左对齐，并且使用空格填充长度with的新字符串
print(mystr.ljust(50))
# 结果为:hello python hello pythonWorld      "

# rjust 返回一个字符串右对齐,并使用with来填充字符串的长度
print(mystr.rjust(50))
# 结果为:"                    hello python hello pythonWorld

# lstrip 删除mystr左边的空白
print(mystr.lstrip())
# 结果为:hello python hello pythonWorld

# rsrtip 删除字符串右边的空白符号
print(mystr.rstrip())
# 结果为:hello python hello pythonWorld

# strip 删除mystr字符串两边的空白符号
print(mystr.strip())
# 结果为:hello python hello pythonWorld

# rfind　类似find　只是从右边开始查找
print(mystr.rfind("python"))
# 结果为:19

# rindex 类似index不过从右边开始查找
print(mystr.rindex("python"))
# 结果为:19

# partition 以　itcast分割成三分
print(mystr.partition('python'))
# 结果为:('hello ', 'python', ' hello pythonWorld')

# rpartition 以 itcast 分割成三分　右边开始寻找分割的字符串
print(mystr.rpartition("python"))
# 结果为:('hello python hello ', 'python', 'World')

# splitlines 按照行进行分割　就是\n　进行分割 返回一个列表
print(mystr.splitlines())
# 结果为:['hello python hello pythonWorld']

# isalpha 如果mystr所有的字符都是字母就返回True
print(mystr.isalpha())   # mystr里面有空格
# 结果为:False

# isdigit 如果包含数字就为True
print(mystr.isdigit())
# 结果为:False

# isalnum 所有字符都是字母或者数字则返回Ｔrue
print(mystr.isalnum())
# 结果为:False

# isspace 如果mystr中只包含空格,则返回True 否则返回Flase
print(mystr.isspace())
# 结果为:False

# join　在列表的每个字符后面插入新的字符　，形成新的字符
name = "_"
print(name.join(mystr))
# 结果为:h_e_l_l_o_ _p_y_t_h_o_n_ _h_e_l_l_o_ _p_y_t_h_o_n_W_o_r_l_d

列表的遍历

# for循环遍历
name = ['xiaoWang','xiaoZhang','xiaoHua']
for i in name:
    print(i)

# while循环遍历
name = ["shen", "xiao", "gai"]
length = len(name)

i = 0

while i < length:
    print(name)
    i += 1

列表的添加

# 列表的添加  append
name = ["hello", "world", "python"]
name.append("shen")
print(name)
# 结果是:['hello', 'world', 'python', 'shen']

# 列表的extend的添加
name = ["hello", "world", "python"]
a = ["sex", "age"]
name.extend(a)
print(name)
# 结果为:['hello', 'world', 'python', 'sex', 'age']

 列表的插入

# 列表的插入insert(index, object) index：插入的位置，object:插入的元素
name = ["hello", "world", "python"]
b = "wo_shi_b"
name.insert(0, b)
print(name)
# 结果为:['wo_shi_b', 'hello', 'world', 'python']

列表的修改

# 列表的修改元素  直接根据下标进行修改
name = ["hello", "world", "python"]
name[0] = "age"
print(name)
# 结果为:['age', 'world', 'python']

列表的删除

# del 根据下标删除　　pop：删除最后一个元素　remove：根据元素进行删除
name = ["hello", "world", "python"]
del name[0]
print(name)
# 结果为:['world', 'python']

# pop从右边开始删除
name = ["hello", "world", "python"]
name.pop()
print(name)
# 结果为:['hello', 'world']

# remove 根据值进行删除
name = ["hello", "world", "python"]
name.remove("hello")
print(name)
# 结果为:['world', 'python']

 列表的排序

# 按照字母进行排序
name = ["hello", "world", "python"]
name.sort()
print(name)  
# 结果为:['hello', 'python', 'world']

# 列表的排序 sort reverse   sort 默认从小到大　reverse = True 大到小
name.sort(reverse=True)
print(name)
# 结果为:['world', 'python', 'hello']

元组的常见操作

# 元组不能被修改，元组使用的是小括号
name = ("hello", "world", "python")

# 访问元组元素根据下表进行访问
print(name[1])
# 结果为:world

print(name.count("hello")) # 元组里面的hello个数
# 结果为:1

print(name.index("world"))  # 元组里面的world个数
# 结果为:1

无序集合

# 无序集合
set1 = {2,3,5,7,2}
print(set1)
# 结果为:{2, 3, 4, 5, 7}

字典的常见操作

# 字典用大括号表示　　有健值对

name = {"name": "shen", "age": 18, "love": "学习"}

# 根据健访问值  健不存在会报错
print(name["name"])    # 结果为:shen

print(name["age"])      # 结果为:18

字典的修改和增加

# 字典的修改元素和列表的差不多，　有健值就修改，没有健值就添加                   
name = {"name": "shen", "age": 18, "love": "学习"}   
name["name"] = "zhang"                             
print(name)                                        
# 结果为: {'name': 'zhang', 'age': 18, 'love': '学习'}  

字典的删除

# 删除元素　del  字典是无序的                             
name = {"name": "shen", "age": 18, "love": "学习"}
del name["name"]    # 删除一个name这个健值对            
print(name)                                    
# 结果为: {'love': '学习', 'age': 18}               

 字典的遍历

# 字典的遍历                     
for i in name.keys():       # 遍历键
    print(i)                
                            
for i in name.values():     # 遍历值
    print(i)                
                            
for i in name.items():      # 遍历键值对
    print(i)                
                            

 全局变量和局部变量

全局变量:作用在全局的变量
局部变量:只能作用在局部的变量 用global声明

 带有返回值的函数

def get_wendu(a):
    wendu = 22
    print("当前的室温是:%d"%wendu)
    return wendu

def get_wendu_huashi(wendu):
    print("------4------")
    wendu = wendu + 3
    print("------5------")
    print("当前的温度(华氏)是:%d"%wendu)
    print("------6------")

print("------1------")
result = get_wendu(1000000)
print("------2------")
get_wendu_huashi(result)
print("------3------")

带有参数的函数

#定义了一个函数
def sum_2_nums(a, b):
    #a = 10
    #b = 20
    result = a+b
    print("%d+%d=%d"%(a,b,result))


num1 = int(input("请输入第1个数字:"))
num2 = int(input("请输入第2个数字:"))

#调用函数
sum_2_nums(num1, num2)

函数的嵌套调用

def sum_3_nums(a, b, c):
    result = a+b+c
    #print("%d+%d+%d=%d"%(a,b,c,result))
    return result

def average_3_nums(a1, a2, a3):
    result = sum_3_nums(a1, a2, a3)
    result = result/3 #result/=3
    print("平均值是:%d"%result)

#1. 获取3个数值
num1 = int(input("第1个值:"))
num2 = int(input("第2个值:"))
num3 = int(input("第3个值:"))

#sum_3_nums(num1, num2, num3)
average_3_nums(num1, num2, num3)

缺省参数

def test(a,d,b=22,c=33):
    print(a)
    print(b)
    print(c)
    print(d)

test(d=11,a=22,c=44)

不定长参数

def sum_2_nums(a,b,*args):
    print("-"*30)
    print(a)
    print(b)
    print(args)

    result = a+b
    for num in args:
        result+=num
    print("result=%d"%result)

sum_2_nums(11,22,33,44,55,66,77)
sum_2_nums(11,22,33)
sum_2_nums(11,22)
#sum_2_nums(11)#错误,因为 形参中 至少要2个实参

def test(a,b,c=33,*args,**kwargs):#在定义的时候 *,**用来表示后面的变量有特殊功能
    print(a)
    print(b)
    print(c)
    print(args)
    print(kwargs)


#test(11,22,33,44,55,66,77,task=99,done=89)

A = (44,55,66)
B = {"name":"laowang","age":18}

test(11,22,33,*A,**B)#在实参中*,**表示对元祖/字典进行拆包

递归函数

def getNums(num):
    if num>1:
        return num * getNums(num-1)
    else:
        return num

result = getNums(4)
print(result)
# 结果为:24

 面向对象

__init__()方法

class Cat:
    """定义了一个Cat类"""

    #初始化对象
    def __init__(self, new_name, new_age):
        self.name = new_name
        self.age = new_age

    #方法
    def eat(self):
        print("猫在吃鱼....")

    def drink(self):
        print("猫正在喝kele.....")

    def introduce(self):
        print("%s的年龄是:%d"%(self.name, self.age))

#创建一个对象
tom = Cat("汤姆", 40)
tom.eat()
tom.drink()
#tom.name = "汤姆"
#tom.age = 40
tom.introduce()

lanmao = Cat("蓝猫", 10)
#lanmao.name = "蓝猫"
#lanmao.age = 10
lanmao.introduce()
# 结果是:
"""

猫在吃鱼....
猫正在喝kele.....
汤姆的年龄是:40
蓝猫的年龄是:10

"""

__str__方法

class Cat:
    """定义了一个Cat类"""

    #初始化对象
    def __init__(self, new_name, new_age):
        self.name = new_name
        self.age = new_age

    def __str__(self):
        return "%s的年龄是:%d"%(self.name, self.age)

    #方法
    def eat(self):
        print("猫在吃鱼....")

    def drink(self):
        print("猫正在喝kele.....")

    def introduce(self):
        print("%s的年龄是:%d"%(self.name, self.age))

#创建一个对象
tom = Cat("汤姆", 40)

lanmao = Cat("蓝猫", 10)


print(tom)
print(lanmao)

私有方法

class Dog:

    #私有方法
    def __send_msg(self):
        print("------正在发送短信------")

    #公有方法
    def send_msg(self, new_money):
        if new_money>10000:
            self.__send_msg()
        else:
            print("余额不足,请先充值 再发送短信")

dog = Dog()
dog.send_msg(100)
# 结果为:余额不足,请先充值 再发送短信

__del__()方法

class Dog:
    def __del__(self):
        print("-----英雄over------")


dog1 = Dog()
dog2 = dog1

del dog1  # 不会调用 __del__方法,因为这个对象 还有其他的变量指向它,即 引用计算不是0
del dog2  # 此时会调用__del__方法,因为没有变量指向它了
print("====================")

# 如果在程序结束时,有些对象还存在,那么python解释器会自动调用它们的__del__方法来完成清理工作

# 结果为:

-----英雄over------
====================

继承

class Animal:
    def eat(self):
        print("-----吃----")
    def drink(self):
        print("-----喝----")
    def sleep(self):
        print("-----睡觉----")
    def run(self):
        print("-----跑----")

class Dog(Animal):
    def bark(self):
        print("----汪汪叫---")


class Xiaotq(Dog):
    def fly(self):
        print("----飞----")


xiaotq = Xiaotq()
xiaotq.fly()
xiaotq.bark()
xiaotq.eat()
# 结果为:

----飞----
----汪汪叫---
-----吃----

多继承

class Base(object):
    def test(self):
        print("----Base")

class A(Base):
    def test(self):
        print("-----A")

class B(Base):
    def test(self):
        print("-----B")

class C(A,B):
    def test(self):
       print("-----C")


c = C()
c.test()

print(C.__mro__)
# 结果为:-----C
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.Base'>, <class 'object'>)

多态

class Dog(object):
    def print_self(self):
        print("大家好,我是xxxx,希望以后大家多多关照....")

class Xiaotq(Dog):
    def print_self(self):
        print("hello everybody, 我是你们的老大,我是xxxx")


def introduce(temp):
    temp.print_self()


dog1 = Dog()
dog2 = Xiaotq()

introduce(dog1)
introduce(dog2)

"""
多态:
1.要发生继承
2.要重写父类方法
3.调用重写的方法
"""

鸭子类型

"""
面向对象语言三大特性:
1.封装: 对象的数据和行为 以属性和方法的形式定义类的里面
2.继承: 想要拥有另一个类的属性和方法
3.多态: 在用父类对象的地方,用了子类的对象
鸭子类形: 并不强求对象/数据的类型,只要对象/数据能完成指定的操作,不报错就可以, 动态类型语言的特性

"""

class Meat:
    """肉类"""
    def __init__(self):
        self.name = "肉"


class Ham(Meat):
    """火腿类"""
    def __init__(self):
        super().__init__()
        self.name = "火腿"


class SweetPotato:
    """地瓜"""
    def __init__(self):
        self.name = "地瓜"
        pass

class Person:
    """人类"""
    def eat(self, meat):
        print("我要吃%s" % meat.name)


m1 = Meat()
h1 = Ham()
digua = SweetPotato()

p1 = Person()
# p1.eat(m1)
# p1.eat(h1)
p1.eat(h1)
# 结果为:我要吃火腿

 

实例方法,类方法,静态方法

class Game(object):

    #类属性
    num = 0

    #实例方法
    def __init__(self):
        #实例属性
        self.name = "laowang"

    #类方法
    @classmethod
    def add_num(cls):
        cls.num = 100

    #静态方法
    @staticmethod
    def print_menu():
        print("----------------------")
        print("    穿越火线V11.1")
        print(" 1. 开始游戏")
        print(" 2. 结束游戏")
        print("----------------------")

game = Game()
#Game.add_num()#可以通过类的名字调用类方法
game.add_num()#还可以通过这个类创建出来的对象 去调用这个类方法
print(Game.num)

#Game.print_menu()#通过类 去调用静态方法
game.print_menu()#通过实例对象 去调用静态方法
# 结果为

100
----------------------
穿越火线V11.1
1. 开始游戏
2. 结束游戏
----------------------

单列模式

class Dog(object):

    __instance = None

    def __new__(cls):
        if cls.__instance == None:
            cls.__instance = object.__new__(cls)
            return cls.__instance
        else:
            #return 上一次创建的对象的引用
            return cls.__instance

a = Dog()
print(id(a))
b = Dog()
print(id(b))

# 结果为:
140278199835112
140278199835112

只初始一次

class Dog(object):

    __instance = None
    __init_flag = False

    def __new__(cls, name):
        if cls.__instance == None:
            cls.__instance = object.__new__(cls)
            return cls.__instance
        else:
            #return 上一次创建的对象的引用
            return cls.__instance

    def __init__(self, name):
        if Dog.__init_flag == False:
            self.name = name
            Dog.__init_flag = True


a = Dog("旺财")
print(id(a))
print(a.name)

b = Dog("哮天犬")
print(id(b))
print(b.name)

# 结果为:
140432460909144
旺财
140432460909144
旺财

异常

try:  # 尝试  如果程序出现错误,它不会直接崩溃,而是执行except里面的代码,然后后续代码依然可以正常执行

    path = input("请输入要读取的文件:")
    f = open(path)
    content = f.read()
    f.close()
    # print(a)

except FileNotFoundError as error: # 只拦截文件未找到的错误
    # 当try里面的代码出现错误,就会自动执行except  来捕获异常,如果try里面代码没有出错就不会执行except中的代码
    print("文件没找到 %s" % error)
except NameError as error:  # 只能拦截变量未定义类型错误
    print("变量未定义 %s" % error)
except:
    print("所有异常都会捕获")
else:  # 当try里面的代码没有错误时会执行,else要写在finally的前面
    print("当try里面的代码没有出错时就会执行")
finally:
    print("无论有没有错误最终都会执行finally里面的代码")
# try在使用时,必须后面要跟一个except或finally,else可跟可不跟
# 异常是分类型的

# BaseException 是所有异常类的基类
print("后续的功能")

自定义异常

# try:
#     # print(b)
#     # 当出现异常会自动创建一个异常对象并抛出
#     raise NameError()  # 手动抛出异常
# except NameError as error:
#     print("%s" % error)


class CustomException(Exception):  # 自定义异常类必须要继承到Exception
    # def __init__(self, info):
    #     self.info = info
    #
    # def __str__(self):
    #     print("----")
    #     return "%s" % self.info
    pass

# 自定义异常就是会了 简化异常
phone_num = input("请输入电话号:")
try:
    if len(phone_num) != 11:
        # print("手机位数不对")
        raise CustomException("手机位数不对")
    elif phone_num.isdecimal() is False:  # 判断是不是纯数字的字符串
        # print("手机号码,输入不合法")
        raise CustomException("手机号码,输入不合法")
except CustomException as error:
    print("提示:%s" % error)
    # 弹出提示框显示错误信息

 

匿名函数

infors = [{"name":"laowang","age":10},{"name":"xiaoming","age":20},{"name":"banzhang","age":10}]

infors.sort(key=lambda x:x['age'])

print(infors)
# 结果为:
[{'name': 'laowang', 'age': 10}, {'name': 'banzhang', 'age': 10}, {'name': 'xiaoming', 'age': 20}]

文件操作

f = open("xxx.txt","r")

content = f.read()
print(content)

f.close()


# 第二种方式
name = input("")
with open("123.txt", "w") as f:
    f.write(name)

is 和==

list1 = [1, 2]
list2 = list1

# == 比较两边变量中保存的值
# if list1 == list2:
#     print("相等")


# is 判断两边变量的引用地址是否相同
if list1 is list2:
    print("相等")
else:
    print("不等")


# 一般比较两个变量的值是否一样都应该用 ==
# 如果比较一个变量/属性是不是为 None False True  等等尽量用is 性能会好点
# 结果为:相等

导入模块

# 模块的导入方式
import sys

from sys import path  # 单独把模块拷贝出来,不是引用

推导式

 

# 列表推导式
# list1 = [i**2 for i in range(1, 11) if i % 2 == 0]

# 字典推导式
# dict2 = {dict1[key]: key for key in dict1}

#匿名函数
# res = (lambda num1, num2: num1 + num2)(1, 2)