Python笔记

标签：Python Series 笔记 df np pd print import

Python笔记（大数据方向）

一、基本数据类型

1、数字类型

1.1、整型（int）

i=100
t=type(i)
print(i,t)

1.2、浮点型（float）

f=12.14
t=type(i)
print(f,t)

1.3、布尔型（False，True）

b=True
t=type(b)
print(b,t)

2、字符串

• 使用单引号将若干个字符括起来的序列，叫做字符串

a1 = '这是一个字符串'

2.1字符串格式化

• 原始字符串拼接做法

# 原始字符串拼接做法
name = input('请输入您的姓名:')
age = input('请输入您的年龄:')
university = input('请输入您的大学:')
major = input('请输入您的专业:')

text = "您的姓名是"+name+",年龄是"+age+",就读于"+university+",专业是"+major
print(text)

• format() 适用于所有版本的python，官方推荐的方式

# 按照索引位置填充
name = input('请输入您的姓名:')
age = input('请输入您的年龄:')
university = input('请输入您的大学:')
major = input('请输入您的专业:')

text = "您的姓名是{0},年龄是{1},就读于{2},专业是{3}".format(name,age,university,major)
print(text)

# 默认按照顺序填充
name = input('请输入您的姓名:')
age = input('请输入您的年龄:')
university = input('请输入您的大学:')
major = input('请输入您的专业:')

text = "您的姓名是{},年龄是{},就读于{},专业是{}".format(name,age,university,major)
print(text) 

# 第一种情况的复用
name = input('请输入您的姓名:')
age = input('请输入您的年龄:')
university = input('请输入您的大学:')
major = input('请输入您的专业:')

text = "您的姓名是{0},年龄是{1},就读于{2},专业是{3}, 不好意思没听清，您的专业是{3}".format(name,age,university,major)
print(text)

# 不用遵循位置，使用变量的方式使用
name = input('请输入您的姓名:')
age = input('请输入您的年龄:')
university = input('请输入您的大学:')
major = input('请输入您的专业:')

text = "您的姓名是{xhz},年龄是{dwd},就读于{wwt},专业是{xh}, 复用{xhz}".format(dwd=name, wwt=age, xhz=university, xh=major)
print(text)

• %

name = input('请输入您的姓名:')
age = input('请输入您的年龄:')
university = input('请输入您的大学:')
major = input('请输入您的专业:')

text = "您的姓名是%s,年龄是%s,就读于%s,专业是%s" % (name, age, university, major)
print(text)

• f-{}的方式 是python3.6版本才开始出现的方式

name = input('请输入您的姓名:')
age = input('请输入您的年龄:')
university = input('请输入您的大学:')
major = input('请输入您的专业:')

text = f"您的姓名是{name},年龄是{age},就读于{university},专业是{major},{name}"
print(text)

2.2、功能

• 转大小写

#转大写upper()
s1 = 'Hello world'
s2 = s1.upper()
print(s1) # Hello worldprint(s2) # HELLO WORLD
#转小写lower()
s1 = 'HELLO WorlD'
s2 = s1.lower()
print(s1)  # 'HELLO WorlD'
print(s2)  # hello world

• 判断字符串的内容是否为数字 isdecimal()

s1 = '100' 
b1 = s1.isdecimal() 
print(b1) # True

• 判断字符串以xxx前缀开头 startswith()

s1 = '我爱数加科技'
b1 = s1.startswith('爱')
print(b1)

• 判断字符串以xxx后缀结尾 endswith()

s1 = '我爱数加科技'
b1 = s1.endswith('爱')
print(b1)

• strip()默认用法：去除空格
  str.strip() ： 去除字符串两边的空格
  str.lstrip() ： 去除字符串左边的空格
  str.rstrip() ： 去除字符串右边的空格

  注：此处的空格包含’\n’, ‘\r’, ‘\t’, ’ ’

a=' abc de a  1'
print(a.strip())
print(a.lstrip())
print(a.rstrip())

• 去除指定字符
  str.strip(‘do’) ：去除字符串两端指定的字符
  str.lstrip(‘do’) ：用于去除左边指定的字符
  str.rstrip(‘do’) ：用于去除右边指定的字符

dodo = "say hello say boy saaayaaas"

# print(dodo.strip('say'))
print(dodo.strip('yas'))
# 当传入的参数中加入空格时
print(dodo.strip('say '))
print(dodo.lstrip('say'))
print(dodo.rstrip('say'))

• 通过索引获取元素

# 字符串名[索引]
name = 'shujiakeji'
print(name[0]) # s
print(name[1]) # i
print(name[-1]) # i

• 切片

info = '我爱数加科技'
print(info[2:4])
print(info[-4:-2])
print(info[::-2])  # 第三个部分代表的是步长

3、列表（list）

是一个可变的,允许发生重复元素的有序序列，将来我们可以使用列表存储我们自己的元素

3.1、创建列表

l=[]
l=list()

3.2、功能

• 增加

  • append（在末尾添加元素）

  list1=list()
  list1.append(10)
  print(list1) # [10]
  

  • insert (根据索引添加元素)

  list2=[1,12,3,11,5]
  list2.insert(1,2)
  print(list2) # [1,2,12,3,11,5]
  

• 修改

  根据索引赋值的新的值

  list3=[1,12,3,11,5]
  list3[1]=2
  print(list3) # [1,2,3,11,5]
  

• 删除

  • remove（删除指定的元素，无返值）

  list2=[1,12,3,11,5]
  list2.insert(1,2)
  print(list2) # [1,2,12,3,11,5]
  list2.remove(2)
  print(list2) # [1,12,3,11,5]
  

  • pop （根据索引删除元素，返回被删除的元素）

  list2=[1,12,3,11,5]
  list2.insert(1,2)
  print(list2) # [1,2,12,3,11,5]
  print(list2.pop(1)) # 2
  print(list2) # [1,12,3,11,5]
  

  • del(python中的关键字)

  list1 = [11, 22, 33, 44, 55, 66]
  del list1[索引]
  

• 反转（reverse()）

list1 = [11, 22, 33, 44, 55, 66]
list1.reverse()
print(list1) # [66,55,44,33,22,11]

• 排序（sort()）

list2 = [1, 12, 3, 11, 5]
list2.sort()
print(list2) # [1, 3, 5, 11, 12]

• 浅拷贝（copy())

list2 = [1, 12, 3, 11, 5]
list3=list2.copy()
print(list3)  # [1, 12, 3, 11, 5]							 

浅拷贝（shallow copy）和深拷贝（deep copy）是在处理复杂对象（如嵌套列表、字典等）时经常用到的概念，它们之间的区别在于复制的程度和对原始对象内部子对象的影响。

1. 浅拷贝：
   • 浅拷贝创建了一个新对象，然后将原始对象的元素复制到新对象中。但对于原始对象内部的嵌套对象，浅拷贝只复制它们的引用，而不是创建新的嵌套对象。
   • 对于不可变对象（如数字、字符串、元组等），浅拷贝和深拷贝没有本质区别。
   • 对于可变对象（如列表、字典等），浅拷贝会复制对象本身，但不会递归复制对象内部的可变子对象。
2. 深拷贝：
   • 深拷贝创建了一个新对象，并递归地复制原始对象及其所有嵌套的子对象。这意味着修改原始对象内部的任何对象都不会影响深拷贝后的对象，它们是完全独立的。
   • 深拷贝通常比浅拷贝花费更多的时间和空间，因为它需要复制整个对象结构。

• 计数（count()）

list1 = [1,2,3,4,1,1,2,3,1,4]
res1 = list1.count(1)
print(res1) # 4

4、元组（tuple）

是一个可以存储有序且重复元素的序列，但是元组是不可变，意味着不允许增删改
只能做查询

4.1、创建元组

tuple1=tuple()
tuple1=()

写法1：当元组中的元素是大于等于2个的时候，最后一个逗号加不加，区别不大

tuple1 = (1,2,3,4) # 创建一个元组，里面有4个元素
tuple2 = (1,2,3,4,) # 创建一个元组，里面有4个元素

写法2：如果元组中只有一个元素，这时候再想一个元组的话，必须加上一个英文逗号

a1 = (11) # 等价于 a1 = 11 11 <class ‘int’>
a2 = (11,) # 创建一个元组，里面有1个元素 (11) (11,) <class ‘tuple’>

4.2、功能

• 根据元素获取索引（index()）

tuple1=(1,2,3)
print(tuple1.index(3)) # 2

5、字典（dict）

元素是一个键-值对的形式存在，一个键对应一个值
键是唯一的
值可以发生重复
一个字典中可以出现多个键值对，python3.6之前字典中的键是无序的，python3.6之后键默认是有序的

注意：并不是所有的数据类型都可以当作键，只有可哈希的类型才能当作键

在Python中，可哈希性对于在字典（dict）中作为键（key）使用的对象至关重要，因为字典的键必须是可哈希的。以下是一些关于可哈希对象的特性：

1. 不可变性： 可哈希的对象必须是不可变的，即对象的内容不能在其生命周期内发生变化。例如，整数、浮点数、元组等是不可变的，因此它们是可哈希的。
2. 稳定的哈希值： 可哈希的对象的哈希值在其生命周期内应该是稳定的，即相同内容的对象应该具有相同的哈希值。
3. 唯一性： 不同内容的对象应该具有不同的哈希值，以确保哈希值的唯一性。

5.1、创建字典

dict1 = dict()
dict2 = {}

5.2、功能

• 获取所有的键（keys()）

dict1 = {'key1': 'aaa', 'key2': 'bbb', 'key3': 'ccc'}
keys = dict1.keys()
print(keys, type(keys)) # dict_keys(['key1', 'key2', 'key3']) <class 'dict_keys'>

• 通过键获取元素（get()）

dict1 = {'key1': 'aaa', 'key2': 'bbb', 'key3': 'ccc'}
print(dict1.get('key1')) # aaa

• 获取所有的元素（values()）

dict1 = {'key1': 'aaa', 'key2': 'bbb', 'key3': 'ccc'}
print(dict1.values())	# dict_values(['aaa', 'bbb', 'ccc'])

• 获取键值对（item()）

dict1 = {'key1': 'aaa', 'key2': 'bbb', 'key3': 'ccc'}
print(dict1.items()) # dict_items([('key1', 'aaa'), ('key2', 'bbb'), ('key3', 'ccc')])

• pop 根据键删除一个元素，返回被删除键对应的值

dict1 = {'key1': 'aaa', 'key2': 'bbb', 'key3': 'ccc'}
s = dict1.pop('key2')
print(dict1) #	{'key1': 'aaa', 'key3': 'ccc'}
print(s) # bbb

• clear() 清空字典中所有键值对

• for循环遍历元素

  方式一：先获取所有的键，在通过键获取值

  dict1 = {'key1': 'aaa', 'key2': 'bbb', 'key3': 'ccc'}
  keys = dict1.keys()
  for key in list(keys):
      value=dict1.get(key)
      print(f'键为：{key},值为：{value}')
      """
  键为：key1,值为：aaa
  键为：key2,值为：bbb
  键为：key3,值为：ccc
      """
  

  方式二：获取所有的键值对

  dict1 = {'key1': 'aaa', 'key2': 'bbb', 'key3': 'ccc'}
  for key_value in list(dict1.items()):
      key = key_value[0]
      value = key_value[1]
      print(f'键为：{key},值为：{value}')
      """
  键为：key1,值为：aaa
  键为：key2,值为：bbb
  键为：key3,值为：ccc
      """
  

6、集合（set）

是一个无序（指的是存储和取出的顺序不一致）且唯一的序列

6.1、创建集合

set1=set()

6.2、功能

• 并集 （union()）

set1 = {11, 22, 33, 44}
set2 = {22, 44, 77, 88}
set3 = set1.union(set2)
print(f'set1:{set1}')
print(f'set2:{set2}')
print(f'set3:{set3}') # {33, 11, 44, 77, 22, 88}

• 交集（intersection() ）

set1 = {11, 22, 33, 44}
set2 = {22, 44, 77, 88}
set3 = set1.intersection(set2)
print(f'set1:{set1}')
print(f'set2:{set2}')
print(f'set3:{set3}') # set3:{44, 22}

• difference() 或者 减法- 差集

set1 = {11, 22, 33, 44}
set2 = {22, 44, 77, 88}
# set3 = set1.difference(set2)
set3 = set1 - set2
print(f'set1:{set1}')
print(f'set2:{set2}')
print(f'set3:{set3}') # set3:{33, 11}

• add添加元素

set1 = {11,22,33,44}
set1.add(55)
print(set1) # {33, 11, 44, 22, 55}

• remove() 通过元素的值进行移除 若元素不存在，会报错

set1 = {11, 22, 33, 44}
print(set1)
set1.remove(22)
print(set1) # {33, 11, 44}

• discard() 移除元素 若元素不存在，不会报错

set1 = {11, 22, 33, 44}
print(set1)
set1.discard(22)
print(set1) # {33, 11, 44}

• pop：根据set集合中的结果按照顺序弹出

set1 = {11, 22, 33, 44, 55, 66, 77, 88, 99, 100, 23, 41, 23, 14, 17, 31}
print(set1) # {33, 66, 99, 100, 41, 11, 44, 77, 14, 17, 23, 22, 55, 88, 31}
res = set1.pop()
print(res) # 33
print(set1) # {66, 99, 100, 41, 11, 44, 77, 14, 17, 23, 22, 55, 88, 31}
res = set1.pop() 
print(res) # 66
print(set1) # {99, 100, 41, 11, 44, 77, 14, 17, 23, 22, 55, 88, 31}

二、运算符

1、算术运算符

2、比较运算符

3、赋值运算符

4、位运算符

5、逻辑运算符

6、成员运算符

7、身份运算符

8、运算符的优先级

三、文件操作

1、操作文件的步骤

1、打开文件
2、操作文件
3、关闭文件

2、打开文件的模式

3、文件的读写

• 读

f=open('D:\\ershijiuqi\\FuXi\\list\\file\\29复习.txt',mode='rb')
text=f.read().decode(encoding='UTF-8')
f.close()
print(text)

• 写

file = []
f = open('D:\\ershijiuqi\\FuXi\\list\\file\\29复习.txt', mode='rb')
text = f.read().decode(encoding='UTF-8')
text_list = text.split('\r\n')
for info in text_list:
    file.append(info)
f.close()
# print(text)
print(file)
#将列表中的数据写入到test.txt文件中
f1 = open('D:\\ershijiuqi\\FuXi\\list\\file\\test.txt', mode='ab')
for i in file:

    f1.write(i.encode('UTF-8'))
    f1.write('\r\n'.encode('UTF-8'))
f1.close()

• 文件读写方法2：

with open('文件的路径',mode='rb/wb/w/r/ab/a',encoding='编码') as f:
    f.读/写()

四、函数

1、函数的定义

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

2、定义函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号**()**。
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

def fun():
    print("定义函数")


fun()

3、函数的参数

• 形参和实参

形参：在函数定义时的参数

实参：在函数调用时传入的参数

• 位置传参

根据定义时的参数顺序传入参数

def fun1(a, b):
    if type(a) == int and type(b) == int:
        return a+b


print(fun1(1, 2))

• 关键字传参

关键字参数允许在调用函数时指定参数名，参数的顺序可以与定义时不同。

def fun1(a, b):
    if type(a) == int and type(b) == int:
        return a+b

    
print(fun1(b=1, a=2))

• 默认参数

默认参数在定义函数时指定默认值，如果调用时未传递该参数，则使用默认值。

def fun2(a, b=2):
    if type(a) == int and type(b) == int:
        return a + b
    
    
print(fun2(1))

• 参数组（动态参数）

Python提供了 *args 和 **kwargs 来处理不定长参数。

\*args： *args 接收任意数量的位置参数，传递给函数时以元组的形式存在。

def fun3(*args):
    for a in args:
        print(a)


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

**kwargs 接收任意数量的关键字参数，传递给函数时以字典的形式存在。

def fun4(**kwargs):
    list_k = kwargs.items()
    for k in list_k:
        key1 = k[0]
        value1 = k[1]
        print(key1, value1)


fun4(r1=1, r2=2, r3=3)

4、函数的重载

Python 不支持传统意义上的函数重载（即同名函数的不同定义），但是可以通过使用可变参数和默认参数来实现类似的功能。这种方法使得一个函数可以根据传递的参数数量和类型表现出不同的行为。下面我们详细讨论如何利用这些特性实现函数的“重载”。

• 默认参数

def add(a, b=0, c=0):
    return a + b + c


print(add(1))
print(add(1, 2))

• 可变参数

def add1(*args):
    return sum(args)


print(add1(1))
print(add1(1, 2))
print(add1(1, 2, 3))

5、函数的返回值

函数可以返回单个值或多个值。多个返回值会被打包成元组。

#单个返回值
def get_return(a):
    return a


print(get_return(1))
#多个返回值
def get_return2(a, b):
    return a, b


number = get_return2(1, 2)
print(number)
# 可以进行拆包

a, b = get_return2(1, 2)
print(a, b)

6、函数的内置属性

• _name_

返回函数名

• _defaults_

返回函数默认参数，没有返回None

• _annotations_

是一个字典，包含了函数参数和返回值的类型注解

• _globals_

返回一个引用函数全局符号表的字典。这个符号表包含了在函数定义时所在模块中的所有全局变量

7、作用域

• 全局变量：将变量定义在函数的外部
• 局部变量：将变量定义在函数的内部
• global 关键字：可以将局部变量转换成全局变量

def gn():
    global x
    x = 10

gn()
print(x) #注意:被global修饰的变量，只能在函数调用之后才能使用

8、生成器

生成器（Generator）是一种特殊的函数，可以用于迭代地生成一系列值，而不需要一次性生成所有值并将它们存储在内存中。生成器在需要时逐个生成值，并在生成值后暂停执行，保留函数的状态，以便下次调用时能够从停止的地方继续执行。

生成器函数使用 yield 语句来定义，而不是常规函数中的 return 语句。当生成器函数被调用时，它返回一个生成器对象，而不是立即执行函数体。每次调用生成器对象的 next() 方法时，生成器函数将从上次执行停止的位置继续执行，直到遇到下一个 yield 语句。生成器通过生成一个值并将其返回给调用者来实现迭代。

def gen(num):
    while num > 0:
        yield num #yield的作用是相当于return，中断函数
        num -= 1
    return None


g=gen(5)
print(next(g))#5
print(next(g))#4
print(next(g))#3
# next()方法可以通过for循环代替
for i in g:
    print(i)

• 可以使用send()去修改当前保存的值

def gen(num):
    while num > 0:
        tmp = yield num
        if tmp:
            num = tmp
        num -= 1
    return None


g = gen(5)

print(next(g))#5
print(next(g))#4
print(next(g))#3
print(g.send(9))#8

9、内置函数

内置函数 — Python 3.12.6 文档

常见的内置函数

9.1、和数学运算相关

• abs() 求绝对值

a1 = abs(-10)
print(a1)  # 10

• pow() 次方

a1 = pow(2,3)  # 计算2的3次方
print(a1)  # 8

• sum() 求和

list1 = [1, 2, 3, 4, 5]
res1 = sum(list1)
print(res1)

• divmod() 两个数相除得到一个商，一个余数

a1, b1 = divmod(3, 5)
print(a1)  # 商
print(b1)  # 余数

• round() 四舍五入保留小数

a1 = round(1.2367538,2)
print(a1)

9.2、和聚合相关

• min() 最小值

a1 = min([21,3,55,62,3,1])
print(a1)

• max() 最大值

a1 = max([21,3,55,62,3,1])
print(a1)

• all 判断一个序列中，是否都是True,

list1 = [1,2,3,0,5]
res1 = all(list1)
print(res1)  # False

• any 只要有一个是True就可以

list1 = [1,2,3,0,5]
res1 = any(list1)
print(res1)  # True

list1 = [0.0,1,[],0,()]
res1 = any(list1)
print(res1)  # True

9.3、和进制相关

• 十进制、二进制

  • 十进制—> 二进制

  a1 = bin(100)
  print(a1)
  

  • 二进制—> 十进制

  a1 = int('0b1100100',2)
  print(a1)
  

• 十进制、八进制

  • 十进制–>八进制

  a1 = oct(100)
  print(a1)  # 0o144
  

  • 八进制–>十进制

  res1 = int('0o144',8)
  print(res1)
  

• 十进制、十六进制

  • 十进制–>十六进制

  a1 = hex(100)
  print(a1) # 0x64
  

  • 十六进制–>十进制

  res1 = int('0x64',16)
  print(res1)
  

9.4、和字符相关

• ord() 获取对应的ASCII码值

a1 = ord('A') 
print(a1)

• chr() 获取ASCII码值对应的字符

a1 = chr(65)
print(a1)

9.5、和转型相关

• int()
• str()
• bool()
• list()
• tuple()
• dict()
• bytes()

9.6、和获取属性数据相关

• len()
• print()
• input()
• open()
• range()
• hash 计算一个值的哈希值（计算存储位置的）

# 相同的数据，哈希值是一样的
print(hash('ABC'))
print(hash('ABC'))

• type() 查看元素的数据类型的

# 数据类型是可以直接使用==进行比较

• callable 判断一个变量是不是一个函数，判断是否可以执行

a1 = 'abc'
res1 = callable(a1)
print(res1) # False

def fun1():
    print('hello world')
    
res1 = callable(fun1)
print(res1) # True

• enumerate() 获取序列中的索引以及元素值

list1 = [11, 22, 33, 44, 55]
for index, value in enumerate(list1):
    print(f'{index}.{value}')

• sorted() 排序 产生排序后的新列表

list1 = [11, 2, 14, 45, 16]
res1 = sorted(list1)
print(res1)  # [2, 11, 14, 16, 45]
print(list1) # [11, 2, 14, 45, 16]

五、模块

Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。

1、模块的导入方式

• import xxx 直接将大的模块进行导入
• from xxx import xxx 从大的模块中导入小的功能
• as 的方式，对导入的东西的重命名

2、常用的内置模块

2.1. os - 操作系统接口

功能：提供了一系列与操作系统交互的函数，如文件操作、进程管理等。

代码案例：列出当前目录下的所有文件和文件夹

import os

for item in os.listdir('.'):
    print(item)
1234'运行运行

2.2. sys - 系统特定功能

功能：提供访问和使用Python解释器的一些函数，常用于处理命令行参数、退出程序等。

代码案例：打印Python解释器的版本信息并退出程序

import sys

print("Python version:", sys.version)
sys.exit()
1234'运行运行

2.3. json - JSON数据处理

功能：用于编码和解码JSON数据格式。

代码案例：将Python对象转换为JSON字符串并输出

import json

#反序列化
data = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

json_str = json.dumps(data)
print(json_str)
12345678910'运行运行

#序列化

# 将网络中符合json格式的大字符串，转变成python中的数据类型
import json

# info = '''
# {"name":"小虎","likes":["打篮球","踢足球","学习"]}
# '''

# {"name":"小虎","likes":["打篮球","踢足球","学习"]}

# {"name":"小虎","likes":("打篮球","踢足球","学习")}

data = json.loads(info)
print(data['likes'])
print(type(data))

2.4. requests - HTTP库

功能：发送HTTP请求，广泛用于网络爬虫和API交互。

代码案例：发送GET请求获取网页内容

import requests

response = requests.get('https://api.github.com')
print(response.text)
1234

2.5. pandas - 数据分析

功能：提供高性能、易用的数据结构和数据分析工具。

代码案例：读取CSV文件并显示前几行数据

import pandas as pd

df = pd.read_csv('example.csv')
print(df.head())
1234

2.6. numpy - 数值计算

功能：强大的数学库，支持大型多维数组和矩阵运算。

代码案例：创建一个数组并进行简单运算

import numpy as np

arr = np.array([1, 2, 3])
print(arr * 2)
1234'运行运行

2.7. matplotlib - 数据可视化

功能：绘制静态、动态、交互式的图表。

代码案例：绘制简单的线图

import numpy as np
from matplotlib import pyplot as plt
x = np.array(["A", "B", "C", "D", "E", "F"])
y = np.array([78, 13, 44, 99, 150, 8])
plt.bar(x, y)
plt.show()

2.8、time- 时间

• 时间戳

import time
t=time.time()
print(t)

• 日期格式化

from datetime import datetime
print(datetime.now())
print(datetime.now().strftime('%Y/%m/%d %H:%M:%S '))# 2024/09/12 17:35:26

• 常见的类型转换

# 字符串-->datetime类型 strptime()
s1 = "2024-01-12"

s1 = datetime.strptime(s1, '%Y-%m-%d')  # 格式要与字符串的格式一致
print(s1, type(s1))
print('-------------------')
# datetime类型--> 字符串
s2 = datetime.now().strftime("%H:%M:%S  %Y/%m/%d")
print(s1,type(s2))
print('-------------------')
# datetime-->时间戳
s3 = datetime.now() # datetime类型
s3 = s3.timestamp()
print(s3,type(s3))
print('-------------------')
# 时间戳-->datetime类型
res = datetime.fromtimestamp(s3)
print(res)


res = res.strftime("%Y/%m/%d %H:%M:%S")
print(res)

# 时间戳-->datetime类型-->字符串
s4 = datetime.fromtimestamp(1705028697).strftime("%Y/%m/%d %H:%M:%S")
print(s4)

拼接字符串中有中文

s5 = datetime.fromtimestamp(1705028697)
print(s5,type(s5))
time_str = f'{s5.year}年{s5.month}月{s5.day}日 {s5.hour}时{s5.minute}分{s5.second}秒'
print(time_str)

六、异常处理

1、什么是异常

异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。

2、异常处理

• try/except

try:
<语句>        #运行别的代码
except <名字>：
<语句>        #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句>        #如果引发了'name'异常，获得附加的数据

• try/except/else

try:
<语句>        #运行别的代码
except <名字>：
<语句>        #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句>        #如果引发了'name'异常，获得附加的数据
else:
<语句>        #如果没有异常发生

• try/execpt/finally

try:
<语句>        #运行别的代码
except <名字>：
<语句>        #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句>        #如果引发了'name'异常，获得附加的数据
finally:
<语句>        #无论是否发生异常都执行

七、面向对象

1、面向对象的基本特征

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• **类变量：**类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• **数据成员：**类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
• **方法重写：**如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• **局部变量：**定义在方法中的变量，只作用于当前实例的类。
• **实例变量：**在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
• **继承：**即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• **实例化：**创建一个类的实例，类的具体对象。
• **方法：**类中定义的函数。
• **对象：**通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

2、创建类

使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾:

class ClassName:
   '类的帮助信息'   #类文档字符串
   class_suite  #类体

• 实例

class Employee:
    # '所有员工的基类'
    empCount = 0

    def __init__(self, name, salary):
        self.name = name
        self.salary = salary
        Employee.empCount += 1

    def displayCount(self):
        print(f'总员工为{Employee.empCount}')

    def displayEmployee(self):
        print(f'姓名:{self.name},工资:{self.salary}')

• empCount 变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用 Employee.empCount 访问。
• 第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
• self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数,self 不是 python 关键字,可以用其他的符合代替。

3、类的继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。
通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类。

class 派生类名(父类名)
    ...

• 实例

class Parent:  # 定义父类
    parentAttr = 100

    def __init__(self):
        print('调用父类构造函数')

    def parentMethod(self):
        print('调用父类方法')

    def setAttr(self, attr):
        Parent.parentAttr = attr

    def getAttr(self):
        print(f'父类属性 :{Parent.parentAttr}')


class Child(Parent):  # 定义子类
    def __init__(self):
        print('调用子类构造方法')

    def childMethod(self):
        print('调用子类方法')
        
        
 结果：
调用子类构造方法
调用子类方法
调用父类方法
父类属性 :200

• 可以多继承

class A:        # 定义类 A
.....

class B:         # 定义类 B
.....

class C(A, B):   # 继承类 A 和 B
.....

4、方法的重写

如果父类的方法不满足子类，子类可以进行重写

class Parent:        # 定义父类
   def myMethod(self):
      print '调用父类方法'
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print '调用子类方法'
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法

结果：调用子类的方法

• 下表列出了一些通用的功能，你可以在自己的类重写：

序号	方法, 描述 & 简单的调用
1	init ( self [,args…] ) 构造函数 简单的调用方法: obj = className(args)
2	del( self ) 析构方法, 删除一个对象 简单的调用方法 : del obj
3	repr( self ) 转化为供解释器读取的形式 简单的调用方法 : repr(obj)
4	str( self ) 用于将值转化为适于人阅读的形式 简单的调用方法 : str(obj)
5	cmp ( self, x ) 对象比较 简单的调用方法 : cmp(obj, x)

5、多态

python默认支持多态,通过方法的重写来实现的

6、抽象

如果说，类是对一堆对象共同内容的抽取，那么抽象类就是对一堆类共同内容的抽取，包括：属性和方法。可以通过@abstractmethod进行声明。

• 特点

（1）抽象类必须包含一个或多个抽象方法，也可以包含普通方法。
（2）抽象类的抽象方法，在抽象类中并不作实现。
（3）抽象类不能被实例化。

• 实列

# 定义一个动物类
class Animal:
    @abstractmethod
    def eat(self):
        pass


class Dog(Animal):
    @override
    def eat(self):
        print('狗吃肉')


class Cat(Animal):
    @override
    def eat(self):
        print('

标签：Python,Series,笔记,df,np,pd,print,import	

From： https://blog.csdn.net/qq_61732242/article/details/142530891