Part 1, 对于上节课的补充

1. 数据类型--None类型：(字符串是不可变变量，不可变变量就是指定义之后不能修改它的值)

None是空，代表什么都没有，但是它不是空字符串.

而''，是一个字符串对象，代表一个空的字符串。

count+=1和count = count +1是一样
count-=1
count*=1
count/=1

2.if 条件判断的

or and

in 在不在它里面

例：

names='lj,zhx,zhwq,zhwx'print('lj' in names)输出：True

is 判断的是内存地址一样不一样

例：

name1='lj'name2='lj'print(name1 is name2)输出：True

#print(id(变量））可看内存地址

not 取反

例：

names='lj,zhx,zhwq,zhwx'print('lj' not in names)输出： False

---

Part 2, Python数据类型

一，字符串和字符串操作

1，字符串是可以通过下标（索引）来进行取值的，但是由于字符串是不可变变量，不能通过下标来修改它的值

username = 'li'
    username[0]

例：

names='lj,zhx,zhwq,zhwx'print(names[0:6])输出：lj,zhx

python里面的for循环，每次循环的时候，循环的是循环对象里面的每一个元素例：

names='lj,zhx,zhwq,zhwx'for name in names:    print(name)

等于：（python里不要这么写）

names='lj,zhx,zhwq,zhwx'for i in range(len(names)):  #len(names)#取变量的长度    print(names[i])

二，列表

!/usr/bin/python #python里面有个这个话，代表在linux下运行的时候去哪个目录下找python的解释器，在windows上运行不用写

coding:utf-8和 __*__ coding:utf-8 __*__   这两种都在python2里面为了防止中文报错，修改字符集用的，python3里面不用写

列表也叫数组，列表定义，使用[]即可；列表里面可以再套列表，一个里面套一个列表，叫二维数组；一个里面套一个列表，里面的列表再套一个列表，这个叫三维数组，套几层就是几维

定义列表： names=[1,2,3,'LJ',"ZHX"]

通过下标取值：print(names[3]) -->输出：LJ

列表是可变变量，它是可以通下标修改值的

修改值：names[0]='zhwq'    (print(names)  输出：['zhwq',2,3,'LJ',''ZHX''])

对列表的操作，分以下几种增、删、改、查

增：

给list从最末尾添加值: names.append('ZHWX')   (print(names)  输出：['zhwq',2,3,'LJ',''ZHX'','ZHWX'])

指定位置添加元素: names.insert(0,'libby')        (print(names)  输出：['libby','zhwq',2,3,'LJ',''ZHX'','ZHWX'])

删：

names.pop() 默认删除最后一个元素,删谁也把它的值返回了    (print(names)  输出：['libby','zhwq',2,3,'LJ',''ZHX''])

names.pop(2) 删除指定位置的元素     (print(names)  输出：['libby','zhwq',3,'LJ',''ZHX'','ZHWX'])

或使用del关键字删除指定元素 ：del names[2]

清空列表:

names.clear()

删除指定的元素： 要和pop方法区别开来，pop如果删除的话，传是下标

names.remove('libby')

查找值在list里面的次数:print(names.count('LJ'))  -->输出：1

用in来判断一个元素是否在list里面：print('LJ' in names)  -->看输出True/ False

查：

下标是-1的话，代表最后一个元素 ：print(names[-1])

一些内置方法：

names=['libby',1,2,3,'LJ',"ZHX",'zhwx']

print(name.index('LJ'))    #返回查找元素的下标，如果有多个话返回第一个的，如果没有的话就会报错

print(name.index('LJ',2,5))   #后面可以加上查找开始位置和结束位置

两个列表相加：

stu=['peggy','LYX','wm']

print(stu+names)     输出：['peggy', 'LYX', 'wm', 'libby', 1, 2, 3, 'LJ', 'ZHX', 'zhwx']

把另一个列表里面的每个值挨个添加到前面的列表中：

stu.extend(names)
print(stu)                 输出：['peggy', 'LYX', 'wm', 'libby', 1, 2, 3, 'LJ', 'ZHX', 'zhwx']

排序：

nums=[23,34,1,2,345,7,9,343555]
nums.sort()      #默认是升序
print(nums)

输出：[1, 2, 7, 9, 23, 34, 345, 343555]

nums.sort(reverse=True)  #指定reverse=True就是降序
print(nums)

输出：[343555, 345, 34, 23, 9, 7, 2, 1]

nums.reverse()     #反转数组，会改变原数组的值
print(nums)

输出：[343555, 9, 7, 345, 2, 1, 34, 23]

多维数组（列表，list）：

lis=[1,'lily',19.8,['lily','lilei',['heheh','haha']]]
print(lis[3][2][1])

输出：haha

三，字符串方法

所有字符串的方法，它都不会修改原来字符串的值，都会产生一个新的字符串

name='hello world'
print(name.capitalize())   输出：Hello world          #首字母大写

print(name.center(100,'*'))   输出：********************************************hello world*********************************************     #100个*，把name放中间

print(name.endswith('d'))   输出：True       #判断字符串是否以“d”结尾

print(name.find('world'))    输出：6            #查找字符串的索引，找到的话返回第一次出现的索引，找不到返回-1

print(name.format(name='niuniu', age=18))      #格式化字符串

print(name.format_map({'name':'niuniu','age':19}))    #这个也是格式化字符串，后面跟的是一个字典

print('abA123'.isalnum())      输出：True      #判断字符串是否包含数字和字母

print('abA'.isalpha())            输出：True      #判断字符串是否是英文字母

print('122'.isdigit())             输出：True       #判断字符串是否是数字

print('aa'.isidentifier())         输出：True       #判断是否是一个合法的变量名

print('aa'.islower())              输出：True       #判断是否是小写字母
print('AA'.isupper())             输出：True       #判断是否是大写字母

print(name.upper())             输出：HELLO WORLD  #变成大写
print(name.lower())              输出：hello world       #变成小写

names=['LJ','ZHX','sffffff']
print('+'.join(names))         输出：LJ+ZHX+sffffff

或

strname='ABCDEF'
print('&'.join(strname))      输出：A&B&C&D&E&F           #join是用来通过某个字符串拼接一个可迭代对象的的每个元素的

print('\nmysql \n'.lstrip())                 #默认去掉左边的空格和换行
print('\nmysql \n'.rstrip())                 #默认去掉右边的空格和换行
print('\nmysql \n'.strip())                  #默认去掉两边边的空格和换行

print('mysqlm      '.strip('m'))     输出：ysql      #当你传入某个字符串的话，它就只会去掉你指定的字符串

p = str.maketrans('abcdefg','1234567')          #前面的字符串和后面的字符串做映射
print('cc ae gg'.translate(p))                          #输出按照上面maketrans做映射后的字符串
#下面是反解
new_p = str.maketrans('1234567','abcdefg')
print('cc ae gg'.translate(new_p))

str='mysql is db...mysql mysql mysql'
print(str.replace('mysql','oracle',1))         输出：oracle is db...mysql mysql mysql       # 替换字符串

print('mysql is is db'.rfind('is'))                输出：9                  #返回最右边字符的下标

name1='LJ,ZHX,sffffff'
print(name1.split(','))    输出：['LJ', 'ZHX', 'sffffff']

#切割字符串，返回一个list，按照你指定的字符串去分隔这个字符串，然后放到一个list里面
如果你什么都不写的话，按照空格分割，多个空格也算一个

print('1+2+3\n1+2+3+4'.splitlines())                 #按照换行符分割

print('Abcdef'.swapcase())                                 #大小写反转

import string
print(string.ascii_letters+string.digits)    输出：abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789   #所有的大小写字母加数字

print(string.ascii_lowercase)               #所有的小写字母   
print(string.ascii_uppercase)               #所有的大写字母
print(string.digits)                              #所有的数字

四，切片

切片，切片也就是另一种方式获取列表的值，它可以获取多个元素，可以理解为，从第几个元素开始，到第几个元素结束，获取他们之间的值，格式是name:[1:10]，比如说要获取name的第一个元素到第五个元素，就可以用name[0:6]，切片是不包含后面那个元素的值的，记住顾头不顾尾；前面的下标如果是0的话，可以省略不写，这样写，name[:6]，切片后面还有可以写一个参数，叫做步长，也就是隔多少个元素，取一次，默认可以不写，也就是隔一个取一次，切片操作也可以对字符串使用，和列表的用法一样。

names = ['zcl','py','zyz'] #切片的意思就是从list里面或者字符串里面取几个元素

print(names[0:2])   输出：['zcl', 'py']  #从第几个取到第几个，这个也是顾头不顾尾

print(names[:2])                              #如果是从第一个开始取，取到某一个下标结束，那么最前面是可以不写的
print(names[1:])                              #如果是从前面某个开始取，取到最后面结束，那么最后面是可以不写的
print(names[:])                                 #如果最前面和最后面都不写的话，取整个列表

切片操作对字符串也是完全适用的

name1='zcl,pyzyz'
print(name1[1:5])    输出：cl,p

nums=list(range(1,21))
print(nums[0:10:2])             #如果最后面写上步长的话，就是每隔几个取一次

print(nums[::-1])                 #当切片的步长为负数时，是从末尾开始取值的,然后隔几个取一次

#如果步长为-1的时候，还有反转的功能  （和nums.reverse() 效果一样）

五，元组

元组其实和列表一样，不一样的是，元组的值不能改变，一旦创建，就不能再改变了，比如说，要存数据库的连接信息，这个连接信息在程序运行中是不能被改变的，如果变了那数据库连不上了，就程序就完犊子了，这样的就可以使用元组了，元组呢，也提示别人，看到是元组的话，就说明这个值是不能被改变的

元组的定义方式是用()，小括号，定义元组的时候，如果元组只有一个元素，那么你要在这个元素后面加一个逗号，要不然就是一个字符串。

元组只有两个方法，那就是count和index

例：

tp=(1,2,3,4,5,6,1,1,1)
print(tp[0])                        输出：1
print(tp.count(1))               输出：4
print(tp.index(1))               输出：0

lis=['1','2323']
new_lis=tuple(lis)   （强制类型转换）
print(type(new_lis))   输出： <class 'tuple'>

已学强制类型转换：

#int()
#float()
#str()
#list()
#tuple()

六，字典

字典也是我们开发过程中最常用的一种数据类型，字典dict，全称是dictionary，它具有极快的查找速度；字典是一种key-value的数据类型，比如说要存每个人的信息，那么每个人的编号就是key，value就是每个人的信息，这样的话，一个字典就能存所有人的信息了。字典的定义使用{}，大括号，每个值用“，”隔开，key和value使用“：”分隔。字典里的Key是不能重复的。

例：

info={'name':'xiaoming',
'sex':'nan',
'age':20,
'id':1}

取值： print(info['name'])  输出：xiaoming

print(info['id'])            输出：1
print(info.get('id'))      输出：1

print(info['addr'])  报错

print(info.get('addr'))  输出：None

#用中括号取值和get方法取值的区别，get方法获取不到Key的时候不会报错，中括号取值找不到Key会报错

print(info.get('addr','beijing'))   输出：beijing

#get方法还可以多传一个参数，如果get不到key的话，那么返回**，如果不写的话，默认get不到返回None.

增加：

info['addr']='beijing'   #给字典新增一个值
print(info)

输出：{'addr': 'beijing', 'sex': 'nan', 'age': 20, 'id': 1, 'name': 'xiaoming'}

info.setdefault('phone',13811111)    #给字典新增一个值
print(info)

输出：{'phone': 13811111, 'sex': 'nan', 'name': 'xiaoming', 'id': 1, 'age': 20}

修改：

info['id']=7           #在有这个key的情况下，就是修改这个Key的value,没有这个Key的话，就是新增。
print(info)

输出：{'id': 7, 'age': 20, 'name': 'xiaoming', 'sex': 'nan'}

删除：

del info['id']
print(info)

输出：{'sex': 'nan', 'name': 'xiaoming', 'age': 20}

或者

info.pop('id')     #字典是无序的，pop删除的时候必须指定key，pop方法会返回删除的key对应的value
print(info)

输出：{'sex': 'nan', 'name': 'xiaoming', 'age': 20

info.clear()        #清空字典

info.popitem()    #随机删除一个元素

字典的一些内置方法：

all={'car':{'color':['red','yellow','black'],            'money':111111,            'pailiang':'2.5L',            'name':'BMW'            },     'car1':{'color':['red','yellow','black'],            'money':111111,            'pailiang':'2.5L',            'name':'China'             },     'car2':{'color':['red','yellow','black'],            'money':111111,            'pailiang':'2.5L'             }      }

取car里yellow的值：

print(all.get('car').get('color')[1])

修改car里yellow的值为orange:

all.get('car').get('color')[1]='orange'
print(all)

print(all.keys())    输出：dict_keys(['car2', 'car', 'car1'])     #获取该字典的所有Key

print(all.values())                                                           #获取该字典所有的value

print(all.items())    #获取字典的key和value,循环的时候用

直接循环字典循环的是字典的key，如果想循环的时候同时获取到key和value,那么就要用.item方法。items方法的作用就是为了让你循环的时候同时把key和value取到。输出的是列表，效率比较低。

for k in all:
     print(k,all[k])    #这种方法取值效率比较高

info.update(all)    #把两个字典合并到一起，如果有一样的key,那么更新value.
      print(info)

info.has_key('name') #python2里有这个方法，来判断key是否存在，python3里没有

print('name' in info)  #python3里面直接用in来判断key是否存在

，

七，文件读写

文件打开模式有三种

1，w写模式，它是不能读的，如果用w模式打开一个已经存在的文件，会清空以前的文件内容，重新写。

w+写读模式，只要沾上w,肯定会清空原来的文件

2，r读模式，只能读，不能写，而且文件必须存在

r+读写模式，只要沾上r，文件必须存在

3，a追加模式，也是只能写不能读，在文件的末尾添加内容

4，rb+,wb+,ab+，这种是二进制模式打开或读取，一些音乐文件，图片等。

fw=file('a.txt','r')

#在python2里面可以用file这个函数去操作文件，但是在python3里面只能用open

f=open('a.txt','r',encoding='utf-8')

print(f.read())     #读文件内容，返回的是一个字符串

print(f.readlines())  #读文件内容，返回的是一个列表

print(f.readline())   #只读文件一行的内容

f.write('lj')   #写文件的时候，只能是字符串

f.writelines(['123','456','789'])  #可以把列表写到文件里面

f=open('a.txt')

#如果在打开文件的时候，不指定模式，那就是读模式

f=open('a.txt','a+')    #f代表的是这个文件的对象，也叫句柄
f.seek(0)              #移动文件指针

#文件对象也是可迭代的
print(f.read())

for line in f:
    print(line)        #直接循环文件对象的话，循环的是文件每一行的内容    

修改文件：
修改文件的话，有两种方式，一种是把文件的全部内容都读到内存中，然后把原有的文件内容清空，重新写新的内容；第二种是把修改后的文件内容写到一个新的文件中

第一种：

f=open('a.txt1','a+',encoding='utf-8')f.seek(0)res=f.read()f.seek(0)f.truncate()      #清空文件内容new_res=res.replace('nihao','nibuhao')f.write(new_res)

第二种：

import osf=open('a.txt','a+',encoding='utf-8')f.seek(0)fw=open('a.txt.new','w',encoding='utf-8')for line in f:    new_res=line.replace('学','不学')    fw.write(new_res)f.close()              #关闭文件fw.close()os.remove('a.txt')os.rename('a.txt.new','a.txt')

Flush用法：

import timefw=open('python.txt','w',encoding='utf-8')fw.write('更新博客')fw.flush()         #写完之后立马生效time.sleep(30)fw.close()

With用法：文件不再用的时候，就会自动关闭该文件

with open('python.txt',encoding='utf-8') as fr:    print(fr.read())