python笔记1

1.编码和解码
name="刘勋"
（1）编码:就是把str的数据类型转为bytes的数据类型的过程，使用到的关键字是encode
str_byte=name.encode("utf-8")
print('编码：',str_byte)
print(type(str_byte))
（2）解码: 把bytes的数据类型转为str的数据类型的过程,使用到的关键字是decode
byte_str=str_byte.decode("utf-8")
print('解码:',byte_str)
print(type(byte_str))
2.字符串
str1="hello world"
str2="HELLO WORLD"
查看对象有哪些方法dir，print(dir(str1))
（1）islower（）：判断字符串是否是小写
print('判断str1是否是小写：',str1.islower())
（2）isupper（）：判断字符串是否是大写
print('判断str1是否是大写：',str1.isupper())
（3）upper():把字符串小写转为大写
print('把小写转为大写：',str1.upper())
（4）lower():把字符串大写转为小写
print('把大写转为小写：',str1.lower())
（5）replace()：把一个字符串替换为另一个字符串
print('把world替换为python：',str1.replace("world","python"))

(6)字符串拆分后，就会把字符串从str类型转为list类型，splite()
str_list=str1.splite(' ')
print(str_list)
print(type(str_list))
(7)字符串的合并，也就是join的方法，是把lisst转为str的过程，join()
#str_list=["hello","python"]
list_str='_'.join(str_list)
print(list_str)
(8)消掉字符串后面的空格

str3="hi "
print(str3.strip())
(9)startwith():字符串是以什么开头；
    endswith():字符串是以什么结束；
    index():获取字符串i的索引信息
str4="hi python"
print("以什么开头：",str4.startswith("hi"))
print("以什么结束：",str4.endswith("hh"))
print("获取i的索引信息：",str4.index('i'))
(10)对字符串进行循环
str5="我的中国心"
for item in str5:
 print(item)
3.字符串的判断
str1="无涯"

str2="无涯"
str3=str2
（1）==：类型与内容一致，那么两个对象是相等的。主要比较的是内容和具体的数据类型

if str1==str2:
  print('pass')
（2）is：is比较的是两个对象的内存地址（隐含了类型与内容一致）。比较两个对象的内存地址

if str2 is str3:
  print('两个对象的内存地址是一致的')
（3）in：比较的是内容包含，也暗含了数据类型，因为比较首先前提是数据类型是一致的

str4="无涯博雅教育科技"
 if str2 in str4:
     print('str4包含了str2的内容')
（4）index是索引，item是循环的内容，enumerate是获取的索引信息

str1="无涯教育"
 for index,item in enumerate(str1):
    print(index,item)
       if index==1:
   print('天涯海角')
4.列表的几种操作方法
 list1=[1,8,10,"Go",8,"Python"]
 list3=[".NET"]
（1）append:添加元素到最后一位
list1.append('佩奇')
 print(list1)
（2） insert:按照索引信息添加
 list1.insert(0,'测试开发')
  print(list1)
（3）copy:复制
list2=list1.copy()
 if list1==list2:
  print('copy后的内容是一致的')
 print(list2)
（4）index:获取对象的索引信息
 print('获取10的索引信息：',list1.index(10))
（5）pop:删除列表中的最后一位，并且把删除的元素返回来
 print('删除最后一位：',list1.pop())
（6） remove:可以删除任何一位
list1.remove(10)
print('remove可以指定删除的元素：',list1)
（7） count:对象有几位
 print('count指获取的对象有几个：',list1.count(8))
（8）extend:两个列表的合并
list1.extend(list3)
print('合并后的结果信息：',list1)
（9）reverse：用于将列表中元素进行反向操作，即逆序排序

list4=[90,9,18,5,88,32,45]
 list4.reverse()
 print(list4)
（10）sort:列表的排序
list4.sort()
print('排序后的结果信息:',list4)
5. 元组
（1）定义： List是可变的，tuple是不可变的。但是tuple里面的对象内容是可变的，这点需要特别注意。
当tuple里面的对象并且只有一个的时候，记得需要加，如果不加的话，就不再是tupled的数据类型，具体案例代码如下：
Lists=[80,"hello","world","love"]
***切片操作如下：
（2）元组中的lists[0:2]:获取到元组的前两位元素
Print('只获取到前两位元素：',lists[0:2])
（3）lists[-1]:获取到元组的最后一位元素

Print('获取最后一位：',lists[-1])
（4）lists[2:4]:获取到元组的最后两位元素
Print('获取最后两位：,lists[2:4])
（5）index:元组获取所有信息的方法
 Tuple1=("go","python")
 Print('获取索引信息：',tuple1.index("python"))

6.字典
dict1={"name":"liuxun","age":"22","city":"hanzhong","work":"测试开发工程师"}
（1）字典的key值获取方法
print(dict1.get("name"))
print(dict1['name'])
（2）字典的合并
dict2={"salary":"2300"}
dict1.update(dict2)
print(dict1)
（3）sorted()排序
print('根据key值来进行排序：',dict(sorted(dict1.items(),key=lambda item:item[0])))
print('根据value值来进行排序：',dict(sorted(dict1.items(),key=lambda item:item[1])))
print('获取所有key值：')
（4）对字典进行循环
for key in dict1.keys():
 print(key)
 for value in dict1.values():
     print(value)
     print('对字典进行循环：\n')
for key,value in dict1.items():
    print(key,':',value)
（5）获取字典里的值
 datas={"data":[{"name":"wuya","age":[{"salary":1009}]}]}
 print('获取name的值：',datas['data'][0]['name'])
print('获取age的值：',datas['data'][0]['age'][0]['salary'])
7.函数
（1）形式参数：形式参数只有在函数进行被调用的时候才会在内存中分配内存单元，在调用结束后，即刻释放所分配的内存单元。所以说，形式参数只有在函数内部是有效的
（2）实际参数：实际参数就是函数在被调用的时候，赋予形式参数具体的值，也就是实际参数
username和password就是形式参数；"liuxun"和"0223"就是实际参数
 def login(username,password):
  if username=='liuxun' and password=='0223':
    print('登录成功')
  else:
     print('账户或密码错误')
    login(username='liuxun',password='0223')
（3）*:元组；**：字典

def func(*args,**kwargs):
     print('args',args)
     print('args的类型:',type(args))
     print('kwargs',kwargs)
print('kwargs的类型：',type(kwargs))
     func(("go","python"))
     func([1,2,3])
（4） 动态参数：1.当形式参数的个数不确定

2.当形式参数的数据类型不确定

func(name='liuxun',age='22',sex='girl',salary=2500)

（5）用函数返回值把函数与函数之间或者方法与方法之间建立一层函数关系
 一个函数，不管是否写return的关键字，函数都是有它的返回值的， 如果在定义的函数里面没有写return的关键 字，
那么函数的返回值为None，如果写了，函数的返回值就是return后面的内容。同时需要说明的是一个函数， 可以有N个返回值。

def login(username='liuxun',password='0223'):
 if username=='liuxun' and password=='0223':
     return 'liuxun0223'
  else:
     print('账户或密码错误')
 #token既可以做参数参数，也可以做函数方法
 def profile(token):
     if token=='liuxun0223':
         print('欢迎查看个人主页')
     else:
         print('请登录您的账户信息')
 profile(token=login())
（6）局部变量和全局变量
在函数里面定义的变量是局部变量，而在python程序开始定义的变量是全局变量，全局变量作用域是整个函数，
而局部变量的作用域仅仅是函数而已，当局部变量与全局变量的名字是一样的时候，在函数内部，局部变量是第一优先级，而函数外，全局变量是第一优先级
 name="刘勋"
 def func():
     global  name
     name='liuxun'
     print(name)
（7）内部函数（python显示器自带的函数方法）
1)chr:数字转为字母；2）ord:字母转为数字
 import random
 def sign():
     lists=[]
     '''生成验证码的函数'''
     for item in range(10):
         r=random.randrange(9,99)
lists.append(chr(r))
         print(''.join(lists))
 sign()
list2=[1,2,3,4,5,6,7,8,9,10]
 list4=[]
 for item in list2:
     list4.append(item+10)
     print(list4)
（8）filter过滤
def funFilter(a):
    if a>2:
        return True
    print(list(filter(funFilter,list2)))
(9)lambda匿名函数
a=lambda  x,y:x+y
print(a(4,5))
print(list(filter(lambda item:item>2,list2)))
(11)map内置函数：将func作用于seq中的每一个元素，并将所有的调用的结果作为一个list返回。
def mapFun(a):
    return a+10
print(list(map(mapFun,list2)))
print(list(map(lambda item:item+10,list2)))