基本概念：标识符 关键字 变量 数据类型 函数 类

1.Python标识符

标识符由字母、数字、下划线组成。

不能以数字开头，不能包含空格

区分大小写。

有的下划线开头的标识符是有特殊意义的。

2.关键字

在python中有特殊含义的字符

关键字不能用作标识符

import keyword

print(keyword.kwlist)#4.获取所有关键字

 

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

 

3.变量

定义：是一个存储数据的内存空间对象。定义一个变量，即向内存申请一个带地址的访问空间对象，

用来存储数据，通过变量名找到（指向）这个值。例如定义一个变量a，a = 1

 

注意：python变量名本身是没有类型的，类型取决于存储对象，而不是变量名，变量名只是一个指向存储对象的引用，存储对象除了存储数据外还有两个头部信息，一个是类型标志符，标志符用来说明存储对象的数据类型，另一个是引用计算器，用来标明当前存储对象有多少个引用指向它，当没有引用指向这个存储对象的时候，存储对象占用的内存空间将会被python垃圾收集器回收。在python中，没有专门定义常变量的语法，通常用全大写变量名表示，仅是一种提示效果，例如，CITY = "shenzhen" (本质上仍是变量) 。

命名规则：、

变量名称就是自己取的标识符

Python 中的变量赋值不需要类型声明。

每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。

使用变量一定要对变量进行赋值(初始化），只有赋值后的变量才会被创建

可以赋值的数据类型有：（1）数字，（2）字符串，（3）列表，（4）元祖，（5）字典，（6）集合

赋值：

a = b = c = 1    a, b, c = 1,"john",[1,2,3]

a,b=1,2  a,b=b,a(互换）

a,b,c,=1,'*',[1,2,3,]

print(a,b,c)

a,b=b,a

print(a,b,c)

1 * [1, 2, 3]

* 1 [1, 2, 3]

可以用type（）查看存储变量的标志符，（即数据类型），可以用id（）查看变量内存空间的存储地址

可以用del（）删除变量，但是这里删除变量指的是数据被这个变量的引用被删除，不会删除存储对象，实际上这个对象的数据值还存在。以数字1为例子，看下面程序：

a = 1  # 对象 1 被 变量a引用，对象1的引用计数器为1

b = a  # 对象1 被变量b引用，对象1的引用计数器加1

c = a  # 1对象1 被变量c引用，对象1的引用计数器加1

del a  # 删除变量a，解除a对1的引用，对象1的引用计数器减1

del b  # 删除变量b，解除b对1的引用，对象1的引用计数器减1

print(c)  # 最终变量c仍然引用1

结果：1

依然可以输出

再看：

li=[1,2,3,4,5]  #列表本身不包含数据1,2,3,4,5，而是包含变量：li[0] li[1] li[2] li[3] li[4]

a=li[0]     #拷贝列表，也不会有数据对象的复制，而是创建新的变量引用

del li[0]

print(li)      #输出[2, 3, 4, 5]

print(a)   #输出 1

 

 

4.六种数据类型

（1）数字Number

int，float，long，complex

long 类型只存在于 Python2.X 版本中，在 2.2 以后的版本中，int 类型数据溢出后会自动转为long类型。在 Python3.X 版本中 long 类型被移除，使用 int 替代。

数字是不可变的。

 

可以与算术运算符，赋值运算符，比较运算符配合使用，形成新的表达式

a.算术运算符有： +，-，*，/,

%（取模，求余数），//（取整数部分），**（幂运算）

a,b=5,2

print(a%b)#取余数，输出1

print(a//b)#取整数，输出2

print(a**b)#幂运算，输出25

b.赋值运算符

=，右边的结果赋值给左边

+=，-=，*=，/=，%=，//=，**=，左右两边运算后，结果赋值给右边

一般用来while循环中创造变量控制循环次数

c.比较运算符

>,<,>=,>=,==,!=,运算的结果是一个布尔值

 

（2）字符串

由数字，字母，下划线组成，用引号表示。

可以配合成员运算符使用，结果是一个布尔值。

可以配合+，*进行拼接输出和重复输出。

可以通过索引获取每个字符。看程序：

print(str)  # Hello World!

print(str[0])  # H

print(str[2:5])  # llo

print(str[2:])  # llo World!

print(str * 2)  # Hello World!Hello World! *表示重复操作

print(str + "TEST")  # Hello World!TEST 拼接符+连接没有空格，两个字符串可以拼接

print(str,"TEST")  # Hello World! TEST 逗号连接有空格

 

关于字符串的输出问题还有许多内容需要学习。

 

（3）列表

可以包含多种数据类型。

l1=[1,'a',('a',2,3),[1,2,],{1,2,3,},{1:1,2:2}]

可以配合成员运算符使用，结果是一个布尔值。

可以配合+，*进行拼接输出和重复输出。

可以通过索引和步长获取元素。

可以插入和添加元素。也可以删除，修改元素。列表是可变的。有序的。看程序

 

list1=[1,2,3,'a','b','c']

list2=[5,6,7,'x','y','z']

print (list1[0:6:2])               # 输出完整列表 步长为2，间隔一个元素输出 [1, 3, 'b']

print (list1[0])            # 输出列表的第一个元素 1

print (list1[1:3])          # 输出第二个至第三个元素 [2, 3]

print (list1[2:])          # 输出从第三个开始至列表末尾的所有元素 [3, 'a', 'b', 'c']

print (list1 * 2)       # 输出列表两次 [1, 2, 3, 'a', 'b', 'c', 1, 2, 3, 'a', 'b', 'c']

print (list1 + list2)    # 打印组合的列表[1, 2, 3, 'a', 'b', 'c', 5, 6, 7, 'x', 'y', 'z']



list1.append(100)

print(list1)             #列表最后增加元素用append[1, 2, 3, 'a', 'b', 'c', 100]

list1.insert(3,88)

print(list1)            #指定索引号增加元素 [1, 2, 3, 88, 'a', 'b', 'c', 100]

list1[0]=99

print(list1)        #修改[99, 2, 3, 88, 'a', 'b', 'c', 100]，字符串不能按照索引修改

del(list1[0])

print(list1)        #按照指定索引删除[2, 3, 88, 'a', 'b', 'c', 100]

list1.pop()

print(list1)  #pop()默认删除最后一个 [2, 3, 88, 'a', 'b', 'c']

list1.pop(0)

print(list1)  #也可以指定索引删除[3, 88, 'a', 'b', 'c']

 

 

（4）元祖

元组是不可变的

t=()

print(t,type(t))#() <class 'tuple'>空元祖

t1=(1,2,3)

t2=('a','b','c')

print(t1+t2)#元祖可以拼接和重复输出 (1, 2, 3, 'a', 'b', 'c')

print(t1*2)#元祖可以拼接和重复输出 (1, 2, 3, 1, 2, 3)

print(t1[0:3:2])#元祖可以按照索引获取输出 (1, 3)

#t1[0]=99  元祖不可修改，非法

t3=(1,)

print(t3)#只有一个元素的元祖

 

 

（5）集合set

集合中的数据都是无序不重复的，可以增加删除元素。

与成员运算符构成布尔表达式。

不可以用+和*拼接和重复输出。

集合里面不能有列表和字典。

s=set（）定义空集合

 

set1={1,2,3}

set2={2,3,4}

set1.add(88)#增加元素

set2.update({66},{99})#增加元素，注意update是{},可以是多个

print(set1)#{88, 1, 2, 3}

print(set2)#{2, 3, 4, 66, 99} 两个函数增加相同的元素都不会报错



set1.remove(1)#移除元素,只能移除一个，如果原集合中没有，会报错

print(set1)#{88, 2, 3}

set2.discard(999)

print(set2)#{2, 3, 4, 66, 99} 如果原来集合中没有，不报错



print(set1&set2)#交集 {2, 3}

print(set1|set2)#并集 {2, 3, 4, 66, 99, 88}

print(set1-set2)#set1中排除与set2交集剩余的部分 {88}

print(set1^set2)#异或，并集排除交集剩余的部分{4, 66, 99, 88}

 

6.字典dict

字典中保存的都是键值对（key：value），键（key）是唯一的，值value是可以重复的

t={}

print(t,type(t))#() <class 'tuple'>空字典

aa = {'人才':60,'英语':'english','adress':'here'}

print(aa) # {'人才': 60, '英语': 'english', 'adress': 'here'}

aa['价格'] = 100

print(aa) # 1.直接引用字典名称，按key添加{'人才': 60, '英语': 'english', 'adress': 'here', '价格': 100}



xx = {'hhh':'gogogo'}

aa.update(xx)

aa.update({1:2})

print(aa) #2.用方法update添加，写法是()里面写一个字典{'人才': 60, '英语': 'english', 'adress': 'here', '价格': 100, 'hhh': 'gogogo', 1: 2}





del[aa['adress']]

aa.pop('人才')

print(aa)#删除 del或者pop

 

对比

数据类型	表示	有序性	可不可修改	索引
列表	[]	有	可	l[]
元组	(）	有	不可	t[]
集合	{}，空集合set(）	无	可	无
字典	{}	无	可	通过键

 

版权声明：本文为CSDN博主「必修居士」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。

原文链接：https://blog.csdn.net/weixin_43746266/article/details/87713454

函数

1.自定义函数

格式:

      def 函数名(参数列表):

           函数内容

           return 表达式

def:定义函数关键字

函数名:

      标识符

      命名规范:第一个单词全部小写,后面每个单词首字母大写

      add    getValue

参数列表:

      可以没有,如果在写函数的时候有数据不确定,可以把不确定的数据写到参数列表,当做已知条件使用

例如:

      定义一个函数,循环出1-某个数之间的所有数字

def showNum(n):

      for i in range(1,n+1):

           print(i)

注意:

      参数列表中只需要写变量名

      def 函数名(变量名1,变量名2,...):

 

return:

      可以没有,如果函数想要返回一个数据给调用者,需要使用return关键字,return后面的表达式就是要返回的数据

例如:

      定义一个函数,求两个数之和,返回求和结果

      def add(a,b):

           return a+b

          

注意:

      函数不会自己执行,需要手动调用

 

2.函数的调用

格式:

      函数名(实参列表)

注意:

      实参列表必须

传实实在在的参数

例如:

      add(1,2)

 

3.参数传递

      在python中,参数都是对象,对象分为可变对象和不可变对象

      可变对象:list,dictionary，set

      不可变:number,string,tuple

(1)如果传递的参数是不可变的,在函数内改变参数的值,函数外参数不发生改变

例如:

把传进来的数字变成10

def changeNum(n):

   n = 10;

a=1

changeNum(a)

print(a)#结果是 1，不改变a的值

 

(2)如果传递的参数是可变的,在函数内改变参数的值,函数外发生改变

定义一个函数,把列表中的第一个数据该为0

def changeList(list):

   list[0]=0

a=[1,2,3]

changeList(a)

print(a)#结果是[0, 2, 3]，a的值发生改变

 

4.参数类型

(1)必备参数

      调用函数传递的参数要和函数中参数列表一一对应(个数和顺序)

例如:

def showInfo(name,age):

      print("name=",name,"age=",age)



showInfo(12,"小明")#结果是 name= 12 age= 小明

 

          

(2)关键字参数

      调用函数传递参数的顺序和函数中参数列表的顺序不一致

例如:

def showInfo(name,age):

      print("name=",name,"age=",age)



showInfo(age=12,name="小明")#结果是 name= 小明 age= 12

 

 

(3)缺省参数

      如果函数中的参数有默认值,可以不传,如果传了,会修改默认值

例如:

def showInfo(name,age=10):#age有默认的值，只能放后面

      print("name=",name,"age=",age)



showInfo(age=15,name="小明")#name= 小明 age= 15，默认值改变

 

注意:

      默认参数只能放在最后面

 

(4)不定长参数

如果参数的个数不确定,可以使用不定长参数，格式：

def 函数名称(*变量名)

      *表示元祖，是一个序列。**代表字典（定义函数的时候，*表示封包，调用的时候表示解包）

例如:

def add(*a):

    print(type(a))#<class 'tuple'>

    sum=0

    for i in a:

        sum=sum+i

    return sum

sum=add(1,2,3,4,5)

print(sum)#15

 

 

 

def fun1(**a):

    return  a

b=fun1(学号=1,b='x')

print(b,type(b))# {'学号': 1, 'b': 'x'} <class 'dict'>

注意：

这里传参数时候，key默认为字符，不可以写数字，不用引号

 

https://blog.csdn.net/u012965373/article/details/95043996

 

 

class类 通过属性和行为定义一个类，就是将对象的公共属性和公共行为封装为一个class

用变量描述属性（1.内置属性  2.自定义属性），对象的公共属性

                            2.1类变量  2.2实例变量 区别： 通过同一个类创建的对象，类变量值一定都是相同的。但是实例变量就不一定相同。因为实例变量是指同一个类创建的对象中，值不一样的属性。比如人都有两只眼睛，这个就是类变量。每个人都有年龄，年龄就是实例变量，通过self.属性名称来添加，或者通过__init__方法来添加。不同的是通过___init___添加之后，创建对象的时候就要传参来初始化。通过self.属性名来添加可以写在方法中添加。

 

所以：在编程定义一个类的时候，先考虑你要创建一个什么样的对象。这些所有的对象所共有的而且值相同的属性就是类变量。包括最开始的初始值。而共有的属性但是值不一样就是实例变量。

用方法描述行为，对象的公共行为

 

关于内置属性：

 

class animal:

    "定义一个动物类"



    def eat(self):

        print('吃')



a=animal()#创建对象a

a.eat()#通过对象调用类中的方法   吃



print(animal.__name__)#类的名称   animal

print(animal.__dict__)#类中的成员  {'__module__': '__main__', '__doc__': '定义一个4跳腿的动物类', 'eat': <function animal.eat at 0x00000000021A8318>, '__dict__': <attribute '__dict__' of 'animal' objects>, '__weakref__': <attribute '__weakref__' of 'animal' objects>}

print(animal.__module__)#模块名称，如果是类在当前模块中运行，那么他的模块名称是__main__,

                                    # 如果是引用的其他文件名中的类，则他的模块名称就是应用的文件名  __main__

print(animal.__doc__)#类的描述信息   定义一个动物类

 

2.关于自定义属性 类变量

class animal:

    "定义一个动物类"

    leg='有4条腿'

    def eat(self):

        print('能吃')

a=animal()#创建对象a

a.eat()#通过对象调用类中的方法，需要带括号   吃

b=animal()#创建对象b

animal.leg='没有腿'

print(b.leg,animal.leg)#修改了类变量，b也变了，a也变了     没有腿 没有腿

print(a.leg,animal.leg)   #没有腿 没有腿

 

 

关于实例变量

 

class animal:

    "定义一个动物类"

    leg='有4条腿'#类变量

    def __init__(self,x,y):#添加实例变量

        self.name=x

        self.age=y



    def eat(self):

        print('能吃')

a=animal('牛',22)#创建对象a的时候会调用__init__方法对实例变量进行初始化，相当于给name和age赋值，一旦写了__init__之后，创建对象时候必须对实例变量进行初始化。相当于一旦创建对象__init__方法会被默认调用

b=animal('羊',10)

a.leg='没有腿'#这里指，给对象a添加了一个实例变量，不是改变类变量，只能添加当前的对象a，用对象名获取，不改变原来的类中的实例变量。格式：对象名.属性名=值

print(a.leg,animal.leg)  # 没有腿 有4条腿

print(b.leg,animal.leg)#有4条腿 有4条腿 对象b没变 

#__init__方法添加

print(a.name,a.age)#访问对象a中的name和age实例属性成员      牛 22

setattr(a,'name','猪')#修改对象a中的实例变量name属性，为什么修改实例变量的时候，函数的属性名要用引号？

setattr(a,'age',11)#比如我已经创建了对象a，但是相对a进行修改，就用这个setattr方法

print(a.name,a.age)#   猪 11

通过函数对属性增删改

      getattr(object, name)

      setattr(object, name, value)

      delattr(object, name)

           object:修改的对象

           name：属性名

           value：属性值

 

 

time模块

 

import time

#1.时间戳转换为时间元祖 time.localtime方法

print(time.time())#获取当前时间戳

print(time.localtime(time.time()))#将时间戳转化为时间元祖

#time.struct_time(tm_year=2019, tm_mon=12, tm_mday=9, tm_hour=20, tm_min=51, tm_sec=26, tm_wday=0, tm_yday=343, tm_isdst=0)

#分别代表，年月日时分秒，一周的第tm_hour+1几天,一年中的第几天

print(tuple(time.localtime(time.time())))

#(2019, 12, 9, 20, 54, 57, 0, 343, 0) 时间元祖转为一个元祖



#2.时间元祖转换为时间戳 time.mktime方法

time_tuple=time.localtime(time.time())#获取当前时间元祖



time_time=time.mktime(time_tuple)#

print(time_time)





#3.时间字符串转换为时间元祖 time.strptime()方法

#格式：

#%Y 0000年  %y 00年  %m 月 %d日 %H时 %M分 %S秒

cur_time='2019-12-9 20:30'

print(time.strptime(cur_time,'%Y-%m-%d %H:%M'))#time.strptime()方法 格式在后



#4.时间元祖转换为字符串 time.strftime()

print(time.strftime('%Y:%m:%d %H:%M:%S',time_tuple))#time.strftime()，格式在前





#time模块计算你出生了多少天

import time

cur_time=time.time()

bir_time=input('按格式输入你的生日（20191001）：')

bir_time=time.mktime(time.strptime(bir_time,'%Y%m%d'))

live_day=(cur_time-bir_time)/24/3600

print('活了%d天：'%int(live_day))

 

 

 

datetime模块中的datetime类

from datetime import datetime#从datetime模块中导入datetime类

time_obj=datetime.now()#获取当前时间对象now方法 输出为   2019-12-09 21:48:16.798000

time_obj1=datetime(2019,12,9,10,30)#可以用datetime类来创建对象，用对象存储数据,注意月份不能输入01等

print(time_obj1)

#1时间对象转换为时间字符串 显示上修改了的格式 可以将时间对象后面的秒小数点忽略

time_str=datetime.strftime(time_obj,'%Y/%m/%d %H:%M:%S')

print(time_str)#2019/12/09 22:01:03



#2时间字符串转换为时间对象

time_obj=datetime.strptime(time_str,'%Y/%m/%d %H:%M:%S')

print(time_obj)#时间对象默认用-连接显示年月日  2019-12-09 22:01:03

 

同时引入time和datetime

 

from datetime import datetime#从datetime模块中导入datetime类

import time



#时间戳转换为时间对象，时间对象转换为时间元祖

cur_time=time.time()

time_obj=datetime.fromtimestamp(cur_time)

print(time_obj)



time_tuple=time_obj.timetuple()

print(time_tuple)

######################################



#关于时间差

#用时间差获时间

from datetime import timedelta,datetime

time_obj=datetime.now()+timedelta(-1)#前一天  2019-12-08 22:23:27.574000

print(time_obj)

time_obj=datetime.now()+timedelta(1)#后一天  2019-12-10 22:23:27.574000

print(time_obj)

time_obj=datetime.now()+timedelta(1,hours=1,minutes=30)#2019-12-10 23:53:27.574000 后一天零1个半小时

print(time_obj)



#两个时间对象相减，结果是一个时间差对象

time_obj=datetime(1991,11,20)

time_long=datetime.now()-time_obj

print(time_long)

print(time_long.days,time_long.seconds)#获取时间差的天数和秒

 

 

 

 

file=open('C:/Users/Administrator/Desktop/test.txt','r')#创建文件对象

print(file.name)#访文件名称

print(file.closed,file.mode)#访问文件属性,是否关闭，文件模式

file.close()#关闭

print(file.closed)#Ture表示关闭



file1=open('C:/Users/Administrator/Desktop/test1.txt','w')

file1.write('hello world')

file1.closed



file=open('C:/Users/Administrator/Desktop/test.txt','r')

copyfile=open('C:/Users/Administrator/Desktop/test1.txt','w')

copyfile.write(file.read())#复制一个文件，read()方法读取所有方法

copyfile.close()

 

# r ：以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。

#

# rb： 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。

#

# r+： 打开一个文件用于读写。文件指针将会放在文件的开头。

# rb+： 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。

#

# w ：打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

#

# wb： 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

#

# w+： 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

#

# wb+： 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

#

# a ：打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

#

# ab ：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

#

# a+ ：打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。

#

# ab+： 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

# ————————————————