Python笔记-高级变量

1.列表

name_list["aaa","bbb","ccc"]

2.列表的方法

增  name_list.append()  name_list.insert()  name_list.extend()
删  name_list.remove()   name_list.pop()
查  print(name_list)   print(name_list[0])
改  name_list[1]=''

3.列表的统计

list_name.count('zhangsan')
len(list_name)

4.列表的排序和反转

name_list.sort() 升序

5.列表的循环遍历

for x in name_list
    print(x)
将name_list每次遍历的数据放在x中并且输出

 例如1

def test():
    list_name = ["zhangsan", "lisi", "wangle"]  # 定义列表
    test_list = ["小学", "高中", "大学"]

    # 1.取值取索引
    print(list_name)  # 输出列表的所有内容+
    print(list_name[0])  # 输出列表索引为0的值
    print(list_name.index('lisi'))  # 输出已知数据的下标

    # 2.添加
    list_name.append("admin")  # 末尾追加值
    list_name.insert(1, "插入数据")  # 在指定位置插入数据
    list_name.extend(test_list)  # 把其他列表追加到当前列表
    print(list_name)

    # 3.修改
    list_name[1] = "root"  # 修改下标为1的值为root
    print(list_name)

    # 4.删除
    list_name.remove("小学")  # 删除小学
    list_name.pop()  # 默认删除最后一项
    list_name.pop(1)  # 删除下标为1的值
    # list_name.clear()  # 清空列表
    print(list_name)

    # del list_name[2]  # 把变量从内存删除,后续不允许在调用,慎用
    list_len = len(list_name)  # 计算列表的长度
    print(list_len)
    count = list_name.count('zhangsan')  # t统计某一元素出现的次数
    print(count)


test()

例如2 

# 列表排序练习
import keyword


def list_sort():
    list1 = ['2', '3', '7', '0', '-8', '20']
    list2 = ['zhangsan', 'lisi', 'wamgw', 'ylojbk', 'hm']
    print(list1)
    print(list2)

    list1.sort()  # 正序
    list2.sort()
    print(list1)
    print(list2)

    list1.sort(reverse=True)  # 逆序
    list2.sort(reverse=True)
    print(list1)
    print(list2)

    list1.reverse()  # 反转
    list2.reverse()
    print(list1)
    print(list2)


list_sort()

print(len(keyword.kwlist))

6.元组和列表的区别
定义() []的区别
列表可以修改  元组不能修改

7.元组的循环
实际场景运用不多

# 定义一个空元组
tuple = ()

# 定义只有一个元素的元组
tuple_list = (10,)

# 测试开始
tuple_list1 = ('123', 5, 999, 'lisi')

# 元组的取值和取索引
print(tuple_list1[1])
print(tuple_list1.index(5))

# 元组的统计
print(tuple_list1.count(5))
print(len(tuple_list1))

8.格式化字符串

# 格式化字符串
tuple_list2 = ('下水道', 1302, 7.5)
print("住在%s的%d室,房费%.1f元" % tuple_list2)

9.元组和列表的转换
list(元组)
tuple(列表)

# 列表和元组转换
list_num = [1, 2, 3]
print(type(list_num))
list_to_tup = tuple(list_num)
print(type(list_to_tup))

tup_to_list = list(list_to_tup)
print(type(tup_to_list))

9.字典
列表是存储有序的对象的集合
元祖是存储无序的对象的集合
字典是存储键值

dic = {key:value,...}

10.字典的操作
统计
合并
删除
循环输出

# 定义字典
dic = {'name':'字典','age':'15','sex':'男'}

# 字典输出
print(dic)
print(len(dic))

# 字典的合并
dic2 = {'weight':75,'height':150,'age':20}
dic.update(dic2)  # 如果两个字典中有相同的key(age),则数据会覆盖
print(dic)

# 字典的清除
dic.clear()
print(dic)

# 字典的循环遍历
test_dic = {'qq':'10086','age':'18','num':'99'}
for k in test_dic :
    print('%s-%s' %(k,test_dic[k]))

#实际应用场景
car_list = [
    {"test1":"测试1","name":"名字1"},
    {"test2":"测试2","name":"名字2"}
]

for x in car_list :
    print(x)

11.字符串的方法
（

判断
isdecimal、isdigit、isnumeric的共同点:都不能判断小数

查找和修改
str.index()和str.find()的区别：index没有查找到会报错,find则返回-1

文本对齐

去除空白字符

拆分拼接

）

例如1

# 字符串的定义
str = 'name'
str_1 = "i name is 'zhangsan'"

# 输出长度
print(len(str_1))
print(str_1[3])

# 统计某个字符串出现的次数
print(str_1.count('i'))
print(str_1.count('is'))

# 输出字符串的下标
print(str_1.index('i'))
print(str_1.index('is'))

# 循环输出
# for x in str_1 :
#     print(x)

# 输出字符串的所有方法
print(dir(str_1))

例如2

# str = "abcd"
# str = "  \n\t\r"
# str = "(1)"
# str = "一"
str = "abcd"

def str_test():
    # 1.如果字符串中只包含空格,是则返回True
    print(str.isspace())

    # 2.如果字符串中至少有一个字符并且所有字符都是数组或者字母
    print(str.isalnum())

    # 3.如果字符串中至少有一个字符并且所有字符都是字母则返回True
    print(str.isalpha())

    # 4.如果字符串中只包含数字则返回True 全角数字
    print(str.isdecimal())

    # 5.如果字符串中只包含数字则返回True 全角数字 （1） \u00b2
    print(str.isdigit())

    # 6.如果字符串只包含数字则返回True 全角数字 汉字数字
    print(str.isnumeric())

    # 7. 如果字符串是标题化的(每个单词的首字母大写)则返回True
    print(str.istitle())

    # 8.如果字符串中包含至少一个区分大小写的字符,并且所有字符都是小写
    print(str.islower())

    # 9.如果字符串中包含至少一个区分大小写的字符,并且所有字符都是大写
    print(str.isupper())


str_test()

 

例如3

str = "abcd"

def str_test1() :
    # 1.检查字符串是否以s开头
    print(str.startswith('s'))

    # 2.检查字符是否以s结束
    print(str.endswith('d'))

    # 3.检测s是否包含在字符串中,用start和end指定范围,如果是返回开始的索引值,不是返回-1
    # print(str.find('a',__start=0,__end=len(str)))
    print(str.find('c'))

    # 4.类似find()从右往左查找
    # print(str.rfind('a',__start=0,__end=len(str)))

    # 5.类似find()如果str不在string报错
    # print(str.index('a',__start=0,__end=len(str)))

    # 6.类似index() 从右往左找
    # print(str.rindex('a',__start=0,__end=len(str)))

    # 7. 把字符串中的x替换成y,如果指定num 则替换次数不超过num
    # print(str.replace('a','aaaa',num=str.count(1)))
    print(str.replace('a','aaaa'))

str_test1()

 

例如4 

# 字符对齐以及去除空白字符

str = ["望庐山瀑布",
       "李白",
       "日照香炉生紫烟",
       "遥看瀑布挂前川",
       "飞流直下三千尺",
       "疑是银河落九天"
       ]

str_t = ["\t\n\t\n\t\n\t\n\t\n\t\n望庐山瀑布",
         "李白",
         "日照香炉生紫烟\t\n",
         "遥看瀑布挂前川",
         "飞流直下三千尺",
         "疑是银河落九天"
         ]


def str_test1():
    # 1.返回一个原字符串左对齐,并使用空格填充至长度width的新字符串
    for x in str:
        # print(x.ljust(10, ' '))
        print("|%s|" % x.ljust(10, ' '))
    print("—————————————————")

    # 2.返回一个原字符串右对齐,并使用空格填充至长度width的新字符串
    for x in str:
        print("|%s|" % x.rjust(10, ' '))
    print("—————————————————")

    # 3.返回一个原字符串居中,并使用空格填充至长度width的新字符串
    for x in str:
        print("|%s|" % x.center(10, ' '))
    print("—————————————————")

    # 4.截掉字符串左右两边的空白字符
    for y in str_t:
        # print("|%s|" % y.center(10,' '))   # 处理前
        print("|%s|" % y.strip().center(10, ' '))  # 处理后
    print("—————————————————")

    # 5.截掉字符串左边(开始)的空白字符
    for y in str_t:
        print("|%s|" % y.lstrip().center(10, ' '))
    print("—————————————————")

    # 6. 截掉字符串右边(结尾)的空白字符
    for y in str_t:
        print("|%s|" % y.rstrip().center(10, ' '))
    print("—————————————————")


str_test1()

例如5 

str = "　芙蓉楼送辛渐 \t\t\t  王昌龄 \n \t寒雨连江夜入吴 平明送客楚山孤"


def str_test1():
    # 1.把字符串分成一个3元素的元祖(s前,s,s后面)
    print(str.partition('s'))

    # 2.类似partition() 从右开始查找
    print(str.rpartition('s'))

    # 3.以s为分隔符号拆分str,如果num有指定值,则仅分隔num+1个字符串,str默认包含'\r' '\t'  '\n'和空格
    str_list = str.split()
    print(str_list)

    # 4.按照行分隔,返回一个包含各行作为元素的列表
    print(str.splitlines())

    # 5. 以字符串作为分隔符,将seq中所有的元素合并为一个新的字符串
    print(" ".join(str_list))


str_test1()

12.字符串的切片
适用于 字符串 列表 元组
格式:字符串[开始索引:结束索引:步长]

str = 'abcedfghijklmnopqrstuvwxyz'

# 1.截取2-5位
str1 = str[2:5]
print(str1)

# 2.截取从2-末尾
str2 = str[2:]
print(str2)

# 3.截取从开始-5
str3 = str[:5]
print(str3)

# 4.截取完整的字符串
str4 = str[:]
print(str4)

# 5.从索引1开始  每隔一个取一个
str5 = str[1::2]
print(str5)

# 6.从开始,每隔一个字符截取
str6 = str[::2]
print(str6)

# 7.截取从2 -末尾-1的字符串
str7 = str[2:-1]
print(str7)

# 8.截取字符串末尾两个字符
str8 = str[len(str)-2::]
str8_1 = str[-2:]
print(str8)
print(str8_1)

# 9.字符串的逆序
str9 = str[-1::-1]
str9_1 = str[::-1]
print(str9)
print(str9_1)

 字符串的公共方法

str = 'abced'
str_list = ['1', '2', '3']

# len(list) 计算容器中元素的个数
print(len(str))

# del(list) 删除变量
del str_list[1]
print(str_list)

# max(list) 返回容器中元素的最大值  如果是字典,只能比较key
print(max(str))
print(max(str_list))

# min(list) 返回容器中元素的最小值  如果是字典,只能比较key
print(min(str))
print(min(str_list))

# cmp(x,y) 比较x y  python3.0已经取消
# 可以用> < =的方式来比较    字典不能用< >比较

13.python的内置函数
不需要导入外部包,可以直接调用的函数

 

14.运算符
+ 支持 字符串 列表 元组
* 支持 字符串 列表 元组
in 支持 字符串 列表 元组  字典(只判断key)
not in 支持 字符串 列表 元组  字典(只判断key)

---------------------------------------------------------------
1.变量的引用

2.可变类型  不可变类型
可变  内存中的数据可以修改
不可变  内存中的数据不可以修改  注意:字典的键值只能使用不可变类型

3.局部变量和全局变量
局部  在函数内部创建,只能在当前函数体内调用的变量
全局  在函数外部创建,可以在任意函数体调用的变量

4.变量的生命周期
创建 --》调用 --》执行--》系统回收

5.在函数内部修改全局变量的值
global a  在函数内部定义变量为全局
全部全量的位置应在其他函数的上方

6.全局变量命名
a = 1 修改为 g_a =1  global_a = 1