python初学习：基础数据类型、字符串、条件判断、循环、容器、类

芒果-橙

已于 2023-03-04 15:43:20 修改

阅读量968

点赞数

分类专栏：后端文章标签： python 面向对象

于 2022-03-20 20:48:23 首次发布

本文链接：https://blog.csdn.net/qq_35893033/article/details/123620909

版权

后端专栏收录该内容

14 篇文章 1 订阅

订阅专栏

前言

初始内容：python初学知识，包含基础数据类型、字符串、条件判断、循环、容器、类定义
博客地址：芒果橙的个人博客【http://mangocheng.com】

一、基础

1. 基础数据类型

整数
- 二进制：0b开头
- 十六进制：0x开头
浮点
字符串： “ABC”、‘ABC’
- 单字符转义：\
- 单个字符串（行）转义，表示一个raw字符串，里面的字符不用转义：r’ xxxxx ’ （不包括’'，“”）
- 多行转义：‘’’ xxxxxx ‘’’
- 多行单个字符串（raw字符串)： r’‘’ xxxxxxx ‘’’
布尔：True、False
- 运算：and、or、not（优先级最高）
空值：None

2. 变量

弱类型，根据赋值决定变量的类型

3. 字符串方法

format：{ } 替换输出

# 字符串模板
template = 'Hello {}'
# 模板数据内容
world = 'World'
result = template.format(world)
print(result) # ==> Hello World

# 指定顺序
template = 'Hello {0}, Hello {1}, Hello {2}, Hello {3}.'
result = template.format('World', 'China', 'Beijing', 'imooc')
print(result) # ==> Hello World, Hello China, Hello Beijing, Hello imooc.
# 调整顺序
template = 'Hello {3}, Hello {2}, Hello {1}, Hello {0}.'
result = template.format('World', 'China', 'Beijing', 'imooc')
print(result) # ==> Hello imooc, Hello Beijing, Hello China, Hello World.

# 指定{}的名字w,c,b,i
template = 'Hello {w}, Hello {c}, Hello {b}, Hello {i}.'
world = 'World'
china = 'China'
beijing = 'Beijing'
imooc = 'imooc'
# 指定名字对应的模板数据内容
result = template.format(w = world, c = china, b = beijing, i = imooc)
print(result) # ==> Hello World, Hello China, Hello Beijing, Hello imooc.

分割

索引取值，类似java的字符串数组

s = 'ABC'
a = s[0] # 第一个
b = s[1] # 第二个
c = s[2] # 第三个
print(a) # ==> A
print(b) # ==> B
print(c) # ==> C

# 取子串，不包括endIndex
a = s[startIndex:endIndex]   

[1:]--获取从位置1开始后面的字符（默认首位是0）

[:-1]--删除位置为-1的字符（也就是获取从位置0带位置-1之间的字符）

[-1:]--获取位置-1的字符

[::-1]--从最后一个元素到第一个元素复制一遍。(也就是倒序)

[:]--相当于完整复制一份str

[1:]、[:-1]和[::-1]详解：参考

索引从前往后为0、1、2...，从后往前 -1、-2、...
[1:]--获取从位置1开始后面的字符（默认首位是0）

[:-1]--删除位置为-1的字符

[-1:]--获取位置-1的字符

[::-1]--倒序(从最后一个元素到第一个元素复制一遍)

[:]--完整复制一份str

4. 条件

if 条件:
    逻辑
else:
    逻辑

# 注意逻辑代码是要缩进的，4个空格

score = 59
if score < 60:
    print('抱歉，考试不及格')
else:
    if score >= 90:
        print('恭喜你，拿到卓越的成绩')
    else:
# elif = else if
if score < 60:
    print('抱歉，考试不及格')
elif score >= 90:
    print('恭喜你，拿到卓越的成绩')

5. 循环

for

for i in arr:
    逻辑

# 嵌套循环
s1 = 'ABC'
s2 = '123'
s3 = 'xyz'
for i in s1:
    for j in s2:
        for k in s3:
            print(i + j + k)

while
```
while True:
    逻辑
```
break：提前终止循环
continue：提前继续循环

6. 容器

6.1 list：列表

有序
任意类型

 sources = [12,23,34]
 list2 = [23,'lebron',44,55]
 num = 0
 for item in list2:
     print(item)
     num = num +1
     if num % 2 == 0:
         print(item)
 
 # 取子列表
 subList = list2[0:3]
 
 # 倒序
 print(list2[-1]) # 55
 print(list2[-2]) # 44
 
 # 添加新元素
 sources.append(44)
 # index插入的位置，value 插入的值
 index = 0
 value = 11
 sources.insert(index,value)
 
 # 删除
 sources.pop()
 firstValue = sources.pop(0)
 
 # 替换
 sources[1] = 'James'
 
 # 多维数组
 l1 = [11,22,33]
 l2 = [44,55,66]
 l = [l1,l2]
 print(l[1,0]) # ==> 44
 for item in l:
     a = item[0]
     b = item[1]
     c = item[2]
     print(a*b*c)

6.2 tuple：元组

有序
基础数据类型（数字、布尔、字符）固定不变，不可添加（性能>>list）
组合类型可变，原因为指向同一个地址
可与list相互转换

 t = ('Alice','Bob','Candy')
 print(t[0:2])
 l = list(t)
 L = ['David','Ellena']
 t2 = tuple(L)
 
 one = (1)
 print(one) # ==> 1 ，因为(1)被解释结果为1
 one2 = (1,) 
 print(one2) # ==> (1,)
 
 # 嵌套
 T = ((1+2),  ((1+2),), ('a'+'b'), (1, ), (1,2,3,4,5))
 print(T) ==> 3 个tuple (3, (3,), 'ab', (1,), (1, 2, 3, 4, 5))
 
 # 可变情况
 T = (1, 'CH', [3, 4])
 L = T[2]
 print(L) # ==> [3, 4]
 # 尝试替换L中的元素
 L[1] = 40
 print(L) # ==> [3, 40]
 print(T) # ==> (1, 'CH', [3, 40])
 # 直接替换tuple中的list会报错
 L2 = [3, 40]
 # 尝试替换tuple中的list
 T[2] = L2 # ==> 报错

方法
- count：统计元素次数
  - index：返回指定元素的下标（注：元素不存在会报错）

6.3 dict：字典

键值对映射
查找速度快 > list
占用内存大 < list
无序（3.5版本）、有序（3.6、3.7）
key不可变（tuple可以作key，list不行）

 d = dict() # ==> {} 空
 d = {
    'Alice':50,
     'Bob':60
 }
 print(d)
 print(d['Bob']) # ==> 60
 
 # 取值
 if 'Alice' in d:
     print(d['Alice']) # 不判空，无key时会报错
 # 使用get方法，key空不会报错
 print(d.get('Ed')) # ==> None
 
 # 添加：无key新增，有key更新值
 d1 = dict()
 d1['Mini'] = 73
 d1['Coco'] = 80
 # 值可以为任意类型
 d2 = dict()
 d2['Mini'] = [72,73]
 d2['Mini'].append(74)
 print(d2) # ==> { 'Mini': [72,73,74]}
 
 # 删除
 d3 = {
     'Alice':60,
     'Bob':20
 }
 alice = d.pop('Alice') # 注意：key不存在会报错
 print(alice) # ==> 60
 print(d) # ==> { 'Bob': 20 }
 # 返回所有key，list类型
 d3['Coco'] = 60
 keys = d3.keys() # ==> [ 'Coco','Bob']
 
 # tuple作为key
 d = dict()
 key = (1, 2, 3)
 d[key] = True
 print(d) # ==> { (1,2,3): True }
 
 # 遍历
 d4 = {
     'Alice':20,
     'Bob':30,
     'Coco':40
 }
 for key in d4:
     value = d4[key]
     print(value)    
 
 for key,value in d4.items():
     print(key,value)
 
 for key in d4.keys():
     print(key)
 for value in d4.values():
     print(value)

方法
- keys：返回所有key，list类型
- values：返回所有value，list类型
- items：返回所有值，包含key和value
- clear：清除所有元素

6.4 set

元素不重复
区分大小写
不是有序的

 # 创建
 s = set([1,2,3])
 print(s) # ==> set([1,3,2]) 
 
 # 判断是否存在
 1 in s # ==> True
 
 # 添加
 names = ['Alice','Bob']
 s1 = set(names)
 s1.add('Coco')
 # 批量添加
 names2 = ['David','Linda']
 s1.update(names)
 
 # 删除
 s2 = set(['Alice','Bob','Coco'])
 s2.remove('Alice')
 print(s2) # ==> set(['Bob','Coco'])
 s2.remove('Tina') # 报错
 
 # 删除
 s3 = set(['Alice','Bob'])
 s3.discard('Alice')
 s3.discard('Coco')
 
 # 清除
 s4 = set(['Alice','Bob'])
 s4.clear() # ==> set([])
 
 # 子集/超集、重合
 s5 = set(['Alice','Bob'])
 s6 = set(['Alice','Bob','Coco'])
 s5.issubset(s6) # True
 s6.issuperset(s5) # True
 s5.isdisjoint(s6) # False 有重合，True 无重合

方法
- add：添加
- remove：删除（元素不存在报错）
- discard：删除（元素不存在不会报错）
- clear：清除所有元素
- issubset：是否子集
- issuperset：是否超集
- isdisjoint：是否重合，有重合False、无重合True

7.函数

引入后，直接调用即可

# 定义
def 函数名(参数):
    函数体

def abs(param):
    if param < 0:
    	return -param
    else:
        return param # 无返回则输出为 None
# 返回多个值使用 ,（逗号）分隔
def square(side):
    perimeter = 4*side
    area = side*side
    return perimeter,area
p,a = square(5) # p=20,a=25
result = square(5) # ==> (20,25)

# 参数可为任意类型
# 判断参数类型
isinstance(100,int) # ==> True
isinstance('23',str) # ==> True

# 默认参数，在必须的参数后面
def power(x,n):
    s = 1
    while n >0:
      n = n-1
        s = s*x
    return s
    
def power(x,n=2):
    s = 1
    while n > 0:
        n = n-1
        s = s*x
    return s
power(3,4) # ==> 3 x 3 x 3 x 3
power(3) # ==> 3 x 3

# 可变参数，任意个数，参数类型实际为tuple   * 必要
def averages(*args):
    for i in args:
        print(i) 
    print(args)
averages(1,2,3) # ==> 1,2,3   (1,2,3)

# 可变关键字参数，给参数定义key，固定参数名，参数类型实际为dict  ** 必要
def info(**kwargs):
    gender = kwargs.get('gender')
    name = kwargs.get('name')
info(gender = 'girl', name = 'Coco')

# 对于一个拥有必需参数，默认参数，可变参数，可变关键字参数的函数，定义顺序如下
def func(param1, param2, param3 = None, *args, **kwargs):
    print(param1)

方法
- isinstance：判断参数类型

二、面向对象

1. 类的定义

# 定义：三种方式
class Person:	pass   # pass为空语句，只是为了保持程序结构的完整性
class Person():	pass
class Person(object):	pass

# 类属性定义
class Animal(object):
 location = 'Asia' # 所有实例均会拥有，只有一份，如果一个实例改了，则同步所有实例
 def __init__(self,name,age):
     self.name = name
     self.age = age
 
dog = Animal('wang',23)        
cat = Animal('miao',12)
print(Animal.location) # ==> Asia
Animal.location = 'Africa'
print(Animal.location) # ==> Africa
dog.location = 'Cn' 
print(dog.location) # ==> Cn ，相当于加了个实例属性
print(Animal.location) # ==> Africa

# 类方法定义：@classmethod
class Animal(object):
 __location = 'Asia'
 def __init__(self):
     pass
 @classmethod
 def set_location(cls,location):  # 第一个参数代表类自身
     cls.__location = location

# 实例：类名+()
mango = Person()
cheng = Person()
# 实例属性的定义
mango.age = 23
mango.sex = 'girl'
print(mango.age) # ==> 23

# 属性的初始化，创建实例会自动调用：__init__() 
class Person(object):
 def __init__(self, name, sex, age): # 第一个参数必须为self（代表自身，名称可变）
     self.name = name
     self.sex = sex
     self.age = age
 
person = Person('mango','girl',23) 

# 实例属性的优先级 > 类属性，实例属性无法修改类属性

# 访问限制
# 私有属性（只能在类内部使用）：__开头
class Animal(object):
 __location = 'Asia'
print(Animal.__location)  # ==> 报错

class Animal(object):
 def __init__(self,name):
     self.__name = name
 def get_name(self):
     return self.__name
dog = Animal('Alice')
print(dog.__name) # ==> 报错

# 实例方法：第一个参数同样为 self，引用，指向实例对象本身
class Person(object):
 def __init__(self,name):
     self.__name = name
 def get_name(self):
     return self.__name
p = Person('Alice')
print(p.get_name()) # ==> Alice

2.类的继承

# 定义继承：(要继承的类)
class Person(object):
    def __init__(self,name):
        pass
class Student(Person):
    def __init__(self,name,gender):
        super(Student,self).__init__(name)  # 初始化从父类继承而来的属性
        self.gender = gender
person = Person('mango')     
student = Student('mango','girl')

# 多态：子类调用方法时会覆盖父类方法，否则顺着继承链调用父类方法

# 多重继承
class children(Teacher,Student):
    pass

# 判断类型：isinstance
isinstance(person,Person) # ==> True
isinstance(person,Student) # ==> False
isinstance(student,Person) # ==> True
isinstance(student,Student) # ==> True
# 获取变量的类型：type
type(person)

# 获取变量的所有属性，返回的是字符串列表：dir

# 获取/设置指定的属性：getattr
getattr(person,'name') # ==> mango
setattr(person,'name','cheng')

# 设置可变参数实例
class Person(object):
    def __init__(self,name,gender,**kwargs):
        self.name = name
        self.gender = gender
        for k,v in kwargs.items():
            setattr(self,k,v)
            
p = Person('mango','girl',age = 23,height = 188)    
print(p.name) # ==> mango
print(p.age) # ==> 23
print(p.height) # ==> 188

3.类的特殊方法

双下划线开头
双下划线结束

# __str__：转化为字符串
num = 23
str(num) # ==> '23'
# __repr__：转化为字符串，显示给开发人员看的，返回的是地址
class Student(object):
    def __init__(self,name):
        self.name = name
    def __str__(self):
        return('name={}'.format(self.name))
    def __repr__(self):
        return('repr name={}'.format(self.name))
s = Student('mango')
print(str(s))  # ==> name=mango
print(repr(s)) # ==> repr name=mango

# __len__：tuple/list的元素个数，如果是对象，需要重写该方法

# 数学运算：加减乘除
# 加法：两个分数a/b和c/d相加等于(a*d+b*c)/b*d，r.p、r.q就相等于前面的c和d
class Rational(object):
    def __init__(self, p, q):
        self.p = p
        self.q = q
    def __add__(self, r):
        return Rational(self.p * r.q + self.q * r.p, self.q * r.q) 
    
    def __str__(self):
        return '{}/{}'.format(self.p, self.q)

# 减法 44





# __slots__：限制随意添加属性
class Student(object):
    __slots__ = ('name','age') # 限定只有这两个属性
    def __init__(self,name,age):
        self.name = name
        self.age = age
s = Student('mango',23)        
s.gender = 'girl' # 报错

# __call__：把类实例变成一个可调用对象
class Fib(object):
    # fib = []
    def __init__(self,num):
        self.fib = []
        for i in range(num):
            self.fib.append(i)  # 随便添加，并非真的是斐波那契数列，下个例子才是
        # print(self.fib)
    def __call__(self,fib):
        # print(self.fib)
        return self.fib

f = Fib(5)
print(f(5)) # ==> [0,1,2,3,4,5]

class Fib(object):
    def __init__(self):
        self.res = []

    def __call__(self, num):
        a = 0
        b = 1
        for x in range(num):
            self.res.append(a)
            a, b = b, a + b  # 斐波那契数列
        return self.res

f = Fib()
print(f(10))

4.模块和包

# main.py 自身的模块
import tools # 导入的模块
from network import tools # 导入network包的tools.py模块

# 定义模块
# tools.py   # 创建一个tools.py文件，在此实现函数功能

# 导入模块
# 导入整个模块：使用时需要带上模块名
import math	
math.pi  
math.pow(2,3)
# 指定导入模块：使用不需要带上模块名
from math import pi  
from math import * # 全部
pi
# 重命名导入模块：解决相同函数冲突问题
from math import pow as mathpow

# 模块导入的路径：官方模块不需要考虑
import sys
print(sys.path) # 该模块路径 ==> [ '','D:/xxxx/',.. ] 第一个空代表当前路径
l = sys.path
l.insert(1,'../')  # 增加解析当前路径的上一级目录
print(sys.path)

# 安装/卸载第三方模块：pip
pip install django
pip uninstall django

5.输入输出

# input：程序输入，输入的为字符串
num = input('input number:')
num = int(num)

# open：打开文件（路径，打开模式）
f = open('text.txt','r') # 当前路径下的text,打开模式为只读模式
f.close
# 打开二进制文件：图片、视频、压缩文件等
f2 = open('test.jpg','rb') # rb 二进制格式只读模式

# 读取内容
# read：读取若干字符
s = f.read(5)
# readline：读取一行，最多返回一行结果
s = f.readline(20)
# readlines：读取多行，包含换行符
s = f.readlines() 

# 写入内容
# write：写入若干字符
f = open('temp.txt','w') # 写模式
f.write('hello')
f.close()
# writelines：写入若干行
lines = ['hello\n','mango\n’，‘cheng\n'] #  三行
f.writelines(lines) # 清空文件内容，重新写入
f.close()
# 通过不同的模式，指定写入的方式
f = open('test.txt','a') # 尾部追加
f = open('text.txt','a+') # 尾部追加，读写
f.readlines() # ==> []  ，因为游标在尾部
f.seek(0) # 移动文件的游标位置：0--文件首部、1--当前位置、2--文件尾部
f.readlines() # ==> 全部内容
# 正确关闭文件：with  ,close 如果在前面的语句发生异常，可能会不执行
with open('test.txt','r') as f:
    pass  # 不需要显示调用close

6.网络编程

服务端：新增Socket、绑定ip和端口、监听连接、接受连接

客户端：新增Socket、连接服务端

# Socket
# server.py
import socket
server = socket.socket() # 1.新建socket
server.bind('127.0.0.1',8080) # 2.绑定
server.listen(5) # 3.监听
connect,address = server.accept() # 4.接受 connect为新的套接字对象、address为地址
print('connect addr：{}'.format(address))
content = connect.recv(1024) # 获取客户端消息 ==> hello world
print(str(content,encoding='utf-8'))
connect.close()

# client.py
import socket
client = socket.socket() # 1.新建
client.connect('127.0.0.1',8080) # 2.连接服务端
client.send(bytes('hello world',encoding='utf-8')) # 发送内容
client.close()

# python自带的HTTP服务器
# 启动
python -m http.server
python -m http.server 8080 -d D:/ # 指定启动 端口和目录路径
    
# 发送http请求：request（建议）、urllib 库
from urllib import request
response = request.urlopen('http://www.baidu.com') #发送请求
print(response)

import request
response = request.get('http://www.baidu.com')
print(response)
content = str(response.content,encoding = 'utf-8')
content_list = content.split('\n') # 分行
for line in content_list:
    if 'www' in line:
        print(line.strip())

7.函数式编程

编程范式

允许有变量，支持高阶函数（函数可作为变量），支持闭包（可返回函数），支持匿名函数

# 1.把函数作为参数
def add(x,y,f):
   return f(x) +f(y)
add(2,3,abs) # abs为取绝对值函数

# 2.map：把函数作用于list里的每一个参数
map(f,list)
for item in map(abs,[-1,2,-3]):
   print(item)
  
# 3.reduce：把函数作用于list里的每一个参数，该函数接收至少2个参数
def prod(x,y):
   return x*y

print(reduce(prod,[1,3,5,7,9])) # 1*3*5*7*9

# 4.filter：过滤，符合条件才取
import math
def f(x):
   r = int(math.sqrt(x))
   if r*r == x:  # 平方根为整数
       return True
   else:
       return False
for item in filter(f,range(1,101)):
   print(item) # 1,4,9,16...
   
# 5.sorted：自定义排序
sorted([23,12,25,66]) # ==> 12,23,25,66
score = [('Alice',23),('Coco',12),('Bob',25),('Dog',66)]
sorted(score) # 按第一个元素排序 ==> ('Alice',23),('Bob',25),('Coco',12),('Dog',66)
# 指定排序字段
def k(item):
   return item[1] # 第二个字段
sorted(score,key = k, reverse=True) # 倒序 ==> [('Dog',66),('Bob',25),('Alice',23),('Coco',12)]
# 忽略大小写排序
def k(item):
   return item.lower()
names = ['Bob','Alice','coco']
sorted(names,key = k)

# 6.返回函数：使用场景1-延迟执行
def f():
   def sub_f():
       print('call sub_f')
   return sub_f
# 返回集合乘积
def cal_prod(l):
   def prod(x,y):  # 也可以嵌套进all_prod里定义
       return x*y
   def all_prod():
       return reduce(prod,l)
   return all_prod

l = [1,2,3]
f = cal_prod(l)
print(f())  # ==>  6   1*2*3

# 7.闭包
# 希望一次返回3个函数，分别计算1x1,2x2,3x3:
def count():
   fs = []
   for i in range(1, 4):
       def f():
            return i*i  # i=3,i=3,i=3
       fs.append(f)
   return fs
f1, f2, f3 = count() # 全部返回9，因为调用的时候，i都等于3

def count():
   fs = []
   for i in range(1, 4):
       def f(j):
           print('j={}'.format(j)) # j=1,j=2,j=3
           def g():
               return j*j
           return g
       r = f(i)
       fs.append(r)
   return fs
f1, f2, f3 = count()
print(f1(), f2(), f3())

# 8.匿名函数：只能由一个表达式，不用return，返回值就是表达式的结果
# 定义：lambda
lambda x:x*x

from functools import reduce
reduce(lambda x, y: x + y, [1,3,5,7,9])

l = ['bob','Alice','Coco']
print(sorted(l,key=lambda x: x.lower()))

# 9.无参数的decorator：接收一个函数作为参数，返回一个新函数,[参考](https://www.jb51.net/article/134782.htm)
# 使用场景：日志、异常信息，类似java的AOP
f = decorate(f)
@   

# 10.偏函数：创建一个调用另外一个部分参数或变量已经预置的函数
def int2(x, base=2): # 转二进制
   return int(x, base)
import functools
int2 = functools.partial(int, base=2)
sorted_ignore_case = functools.partial(sorted, key=lambda item: item.lower())
sorted_ignore_case(['bob', 'about', 'Zoo', 'Credit'])