python3 utc时间并格式化 python datetime utc

一、时间模块

• UTC：国际标准时间, 格林尼治天文时间，UTC+8
• 时间戳（timestamp）：指定时间距离1970.1.1 00:00:00的秒数

1.1 time时间模块

• 使用时间模块前要导入时间模块：import time
• time.time()：获取当前时间对应的时间戳，使用浮点型表示,单位:秒【掌握】

print(time.time())

• time.sleep(休眠时间)：休眠,参数的单位为秒,可以为浮点数【掌握】

time.sleep(2)   #睡眠2秒

1.2 datetime日期模块【重点】

• datetime日期模块是对time模块的封装，比time模块更加全面。
• 使用datetime日期模块前要先导入模块：import datetime
• datetime.datetime.now()：获取当前时间。utcnow获取国际时间

d = datetime.datetime.now()	---> 2018-05-29 11:20:51.432757

• datetime.datetime()：获取指定的时间，通过元组形式

d = datetime.datetime(year=2030,month=1,day=1)

• d1.strftime("%Y.%m.%d")：将时间格式化

print(d.strftime('%Y-%m-%d'))
print(d.strftime('%Y{}%m{}%d{}').format('年','月','日'))

• d.timestamp()：获取时间戳

print(d.timestamp())# 时间戳

• datetime.timedelta()：直接进行加减运算

d2 = datetime.timedelta(days=7,hours=10)
print(d + d2) # 7天10小时候的日期

• datetime.datetime.fromtimestamp()：时间戳转日期对象（了解）

print(datetime.datetime.fromtimestamp(11111111111))

二、面向对象

2.1 面向过程和面向对象的区别

1. 面向过程：

• 在解决问题的时候，侧重于问题是怎样一步一步解决的；
• 代码从上往下依次执行；
• 各个模块之间的关系尽可能的独立的，当import的时候，加载的顺序也是从上往下依次加载。

2. 面向对象：

• 有类的语言就是面向对象；
• 侧重解决问题中涉及到的对象、使用类封装；
• 根据不同的需求执行代码【代码执行顺序不一定】；
• Python是一门面向对象的编程语言，类和对象是 面向对象的核心；
• 好处：可以将复杂的问题简单化。

三、类和对象【重点】

3.1 类的定义

• 语法：
  class 类名:
  类体
• 说明：
  a.Python中使用class关键字定义类
  b.类名只要是一个合法的标识符即可，但是要求：遵循大驼峰命名法则【首单词的首字母大写，不同单词之间首字母大写】
  c.通过缩进区分类体
  d.类体一般包含两部分内容：对类的特征的描述、对类的行为的描述
• 类的三要素：
  事物名称【类名】：举例：人
  事物的特征【变量】：名词，举例：姓名，年龄。。。。
  事物的行为【函数/方法】：动词，举例：吃，跑。。。。

注意：在同一个py文件中可以同时定义多个类，但是，为了提高代码的可读性，结合模块的使用，最好是一个文件一个类

3.2 类中的方法和变量【掌握】

3.2.1 类中的方法和变量的定义

• 类中的方法和变量是为了描述事物的行为和特征。
• 类中元素：
  1、 类中定义的方法被称为成员方法
  2、类中定义的变量被称为成员变量，也被称为属性 [os.name]
  3、成员变量：类具有的特征
  4、成员方法：类具有的行为
• 类存在的意义：拥有相同特征和行为的对象可以抽取出来一个类，类的存在是为了创建一个具体的对象

类中的成员方法区别于普通方法：参数部分一定包含self，而且最好self出现在参数列表的第一个。除此之外，成员方法的用法和普通方法的使用完全相同，也可以设置默认参数或者关键字参数，不定长参数。

• self：具体含义
  self是类中对象方法的一个默认参数，它不是关键字；当通过对象调用对象方法的时候self不需要传参，系统会自动将当前对象传给self(谁调用指向谁)。在对象方法中，是用来调用其他属性和方法。self可以是任意的标识符，只不过为了结合其他编程的使用，习惯上使用self。

1、self的使用：通过self来区分成员变量和局部变量,所以self.name代表name是一个全局变量【成员变量】。
2、使用self之后，可以省略成员变量的定义【掌握】

class Person:
    # 属性

name = 'haha'
    age = 15
    def eat(self):
        print(self.name,'吃饭')
# 创建对象/实例
p = Person()
print(p.name,p.age)
p.eat()

3.2.2 类中方法和属性的使用

• 类属性：
  1、类变量，共享。同一个类的所有对象都有的属性，所有对象都可调用。
  2、类属性调用：类.属性（也可以用对象调用类属性）

calss Pig：
	name = '佩奇'
Pig.name

3、修改类属性，要用类修改，不能用对象修改。如果用对象调用类属性修改，只是新增了一个类属性，不会修改原类属性值。

Pig.name = '猪猪侠'

4、类属性是所有对象共享的！

类，不占内存（类属性占内存）

• 对象属性：
  1、调用：对象属性只能通对象调用，不能通类调用。
  2、如果出现与类属性同名的对象属性，使用对象调用时，会优先使用对象属性。
  3、对象属性的调用：对象属性的值一般会因为对象不同而不一样。

pig1.name1

4、对象属性通过对象调用修改。

对象占内存。

• 对象的创建：
  变量=类(属性参数)

pig1 = Pig('佩奇',10)

• 对象方法的调用：
  对象.对象方法()
• 总结：
  1、类中的成员变量和成员方法随着对象的出现而出现。
  2、访问变量采用：对象名.属性名；访问方法采用：对象名.方法名(参数列表)
• 代码演示：

class Pig:
    name = '佩奇'
    likes = ['吃','睡觉']
    def __init__(self,name1,age):
        # 对象属性/成员变量
        self.name1 = name1
        self.age = age
        # 如果出现与类属性同名的对象属性，使用对象调用时，会优先使用对象属性。
        self.name = '超人强'
        self.likes2 = ['吃', '睡觉']
    def eat(self):
        print(self.name1,self.age,'吃饭')

# 对象：占内存
pig1 = Pig('佩奇',10)
pig1.eat()
pig2 = Pig('乔治',2)
pig2.eat()
# 类属性的调用
print(pig1.name) # 对象.类属性
print(Pig.name)  # 类.类属性【推荐】
# 对象属性的调用
print(pig1.name1)
# 修改对象属性
pig1.name1 = '八戒'
print(pig1.name1)
# 修改类属性，要用类修改，不能用对象修改
Pig.name = '猪猪侠'
print(Pig.name,pig1.name)
print(pig1.likes)  # ['吃', '睡觉']
print(pig2.likes)

3.2.3 内存中的对象

• per = Person()
  说明：
  a.程序中定义的Person类型的变量per实际上是一个变量名，它被存放在栈内存中，他指向实际的Person对象，而真正的Person对象则存放于堆内存中。
  b.类中的成员变量随着对象的出现而出现，随着对象的消失而消失。
  c.每个对象的成员变量会在堆空间中开辟一份自己的空间，相互之间互不影响。

3.3 动态绑定属性和限制绑定

• __slots__变量的作用：限制一个类中的成员变量【程序在运行的过程中，就不能随意的动态绑定属性】
  语法：slots = (属性的名称)

class MyClass():
 #限制属性
 #注意：被限制的属性的名称通过字符串的方式出现在元组的元素中
	__slots__ = ("num1","num2")
 #3.成员方法
	def fun1(self):
    	print("fun1")
	def fun2(self,num):
    	print(num)

#4.创建对象
my = MyClass()
#5.访问类中的成员变量
my.num1 = 11
my.num2 = 22
print(my.num1,my.num2)

#6.调用类中的成员方法
my.fun1()
my.fun2(30)

注意：被限制的属性的名称通过字符串的方式出现在元组的元素中

3.4 构造函数和析构函数【重点】

3.4.1 构造函数

• 语法：def _ _init _ _(self,args1,args2…)

class Ipad:
    # 构造函数
    def __init__(self,price,size,color):
        self.price = price
        self.size = size
        self.color = color

• 调用时机：在对象创建时自动被调用。
• 作用：在这个函数中可以初始化属性
• 注意：
  1、系统默认提供了一个无参的构造函数。当创建对象的时候，默认调用了系统提供的无参的构造函数；
  2、当手动添加了有参的构造函数之后，系统将不再提供无参的构造函数；
  3、当使用构造函数的时候，可以使用无参的，也可以使用有参的，在Python中的解决办法：设置不定长参数。
  4、Python中，一个类中只能有一个构造函数！

3.4.2 析构函数

• 语法： def _ _ del _ _(self):
• 调用时机：在对象销毁时会自动调用。
• 在函数里定义的对象，会在函数结束时自动释放，这样可以用来减少内存空间的浪费。

四、加密模块

• 首先调用：import hashlib

m=hashlib.md5()
m.update('1'.encode())
print(m.hexdigest())  # 32位的16进制

• 加密方法分类：
  1、md5加密：没有解密算法，不可逆，明文和密文一一对应
  2、RSA加密：非对称加密，私钥和公钥
  3、DES,AES加密：对称加密，需要使用key进行加密和解密

五、其他补充

1. 类的属性和对象属性有什么区别?
   类的字段是直接声明在类中的变量，需要通过类来使用；不会因为对象不同 而不一样。 对象属性一般以’self.属性名=值’的形式声明在__init__方法中，需要通过对象来使用，对象属性的值一般会因为对象不同而不一样。
2. 请说明类方法、静态方法和对象方法的区别以及他们的应用场景。
   1)对象方法 a.怎么声明: 直接声明在类中的函数 b.怎么调用: 通过对象来调用 c.特点: 有个指向当前对象的默认参数self；调用的时候不需要传参 d.什么时候用: 实现函数的功能需要用到对象属性
   2)类方法 a.怎么声明: 声明函数前加’@classmethod’ b.怎么调用: 通过类来调用， ‘类.方法名()’ c.特点: 有个默认参数cls, 这个参数在通过类调用的时候不需要传参; 指向当前类(谁调用指向谁) 类能做的事情,cls都可以做 d.什么时候用: 实现函数的功能不需要对象属性的前提下，需要类的字段(需要类)，这个时候就用类方法
   3)静态方法 a.怎么声明: 声明函数前加’@staticmethod’ b.怎么调用: 通过类来调用, ‘类.方法名()’ c.特点: 没有特点(没有默认参数) d.什么时候用:实现函数的功能既不需要对象属性也不需要类的字段，这个时候就使用静态方法。
3. 类属性和对象属性的区别？
   类属性仅是与类相关的数据值，和普通对象属性不同，类属性和实例对象无关。
   即使在多次实例化中调用类，它们的值都保持不变。
   不管如何，类属性不会因为实例而改变它们的值，除非实例中显式改变它们的值。