Python数据内容

Python字符串教程

字符串作为python中最为常见的一种结构，它最典型的特征就是有引号，无论是单引号，或是双引号，还是三引号，它们都是字符串。

"""

   字符串string, 从左向右从0开始，从右向左-1，-2。

"""

a = "abcdef"

print(a[2])

print(a[-2])

 

"""

   字符串的基本操作, python中的字符串是不可变的，会拷贝一份进行修改，原string不变

   切割,并没有slice函数直接中括号，中间使用**冒号**隔开 [起始：结束：步长]

"""

print(a[0:3])   # abc

print(a[0:5:2]) # ace 或者是省略直接写冒号

print(a[::2])   # ace 步长为2表示隔着读取

print(a[1:4:2])   # bd 从b开始读取

print(a[::-2])   # fdb 步长为负数表示从右到左，倒着读

print(a[-1:-4:-2])   # fd 步长为负数表示从右到左，倒着读

print("===========================")

 

"""

   a.capitalize()  字符串**首字母**进行大写

   a.title()  字符串**每个单词的首字母**进行大写

  a.startswith()  字符串是否以某个字串开始

  a.endswith()  字符串是否以某个字串结尾

   a.lower()  字符串所有字母进行小写

   a.upper()  字符串所有字母进行大写

"""

b = "hello world"

print(a.capitalize())

print(b.title())

print(a.startswith("ab"))

print(a.endswith("ab"))

print(a.lower())

print(a.upper())

print(a.islower())

print(a.isnumeric())

 

"""

   a.ljust(self, width, fillchar) 字符串进行左对齐，字符串占用的长度和需要填充的字符

   a.rjust(self, width, fillchar) 字符串进行右对齐，字符串占用的长度和需要填充的字符

   a.center(self, width, fillchar) 字符串进行居中，字符串占用的长度和需要填充的字符

   a.lstrip(char) 删除字符串左边的字符，不写参数的话去除的是左边空格，相当于左边trim()

   a.rstrip(char) 删除字符串右边的字符，不写参数的话去除的是右边空格，相当于右边trim()

   a.strip(char) 删除字符串两边的字符，不写参数的话去除的是两边空格，相当于java的trim()

"""

a = "abcdef"

print(a.ljust(10, "0"))  # abcdef0000

print(a.rjust(10, "0"))  # 0000abcdef

print(a.center(10, "0"))  # 00abcdef00

print(a.lstrip("0"))

print(a.rstrip("0"))

print(a.strip("0"))

 

"""

  a.partition("b") 将字符串以"b"字，分割，如果b在中间且只有一个b，那么返回一个数组[前,"b",后]

   a.splitlines()   将字符串逐行分割，返回一个list，非数组，按需求进行选择方法

   a.isalpha()      字符串是否全是字母，不论大小写，返回bool

   a.isdigit()      字符串是否全是数字，返回bool

   a.isalnum()      前两个的集合体al + num，判断字符串是否包含数字或者字母或者混合也行

   a.isspace()      字符串是否只包含空格

  a.join(["xxx","yyy"])     list中每个元素的后面都插入a字符串

 

"""

b = "ab\ncd\nef"

print(a.partition("b")[1])  # ('a', 'b', 'cdef') -> b

print(b.splitlines())  # ['ab', 'cd', 'ef']

print(a.isalpha())

print(a.isdigit())

print(a.isalnum())

print(a.isspace())

print("x".join(["1", "2", "3"]))  # 1x2x3

print("".join(["1", "2", "3"]))  # 123  将list迅速转换为一个字符串

 

# "abcbdbebf" -> "acdef"

c = "abcbdbebf"

d = c.split("b")  # 去除字符串中所有的b,返回一个list

result = "".join(d)  # list转换为字符串

print(result)

 

"""

   a.ljust(self, width, fillchar) 字符串进行左对齐，字符串占用的长度和需要填充的字符

   a.rjust(self, width, fillchar) 字符串进行右对齐，字符串占用的长度和需要填充的字符

   a.center(self, width, fillchar) 字符串进行居中，字符串占用的长度和需要填充的字符

   a.lstrip(char) 删除字符串左边的字符，不写参数的话去除的是左边空格，相当于左边trim()

   a.rstrip(char) 删除字符串右边的字符，不写参数的话去除的是右边空格，相当于右边trim()

   a.strip(char) 删除字符串两边的字符，不写参数的话去除的是两边空格，相当于java的trim()

"""

a = "abcdef"

print(a.ljust(10, "0"))  # abcdef0000

print(a.rjust(10, "0"))  # 0000abcdef

print(a.center(10, "0"))  # 00abcdef00

print(a.lstrip("0"))

print(a.rstrip("0"))

print(a.strip("0"))

 

"""

  a.partition("b") 将字符串以"b"字，分割，如果b在中间且只有一个b，那么返回一个数组[前,"b",后]

   a.splitlines()   将字符串逐行分割，返回一个list，非数组，按需求进行选择方法

   a.isalpha()      字符串是否全是字母，不论大小写，返回bool

   a.isdigit()      字符串是否全是数字，返回bool

   a.isalnum()      前两个的集合体al + num，判断字符串是否包含数字或者字母或者混合也行

   a.isspace()      字符串是否只包含空格

  a.join(["xxx","yyy"])     list中每个元素的后面都插入a字符串

 

"""

b = "ab\ncd\nef"

print(a.partition("b")[1])  # ('a', 'b', 'cdef') -> b

print(b.splitlines())  # ['ab', 'cd', 'ef']

print(a.isalpha())

print(a.isdigit())

print(a.isalnum())

print(a.isspace())

print("x".join(["1", "2", "3"]))  # 1x2x3

print("".join(["1", "2", "3"]))  # 123  将list迅速转换为一个字符串

 

# "abcbdbebf" -> "acdef"

c = "abcbdbebf"

d = c.split("b")  # 去除字符串中所有的b,返回一个list

result = "".join(d)  # list转换为字符串

print(result)

 

 

 

Python数组教程

数组，一般科班出身的同学会叫它数组，因为在C里面我们是这么叫的，但是有些人更愿意直接叫他列表或list，叫起来更直接，它最典型的特征就是它的中括号[]，基本看到这个就八九不离十了，他就是数组。

"""

   list列表元素的修改操作

"""

a_list = [1,2,3,4]

a_list[2] = "双击666"

print(a_list)

 

"""

   查询list元素 （in, not in, index, count）

   为了避免index方法找不到的报错，解决方案：

   1， 先判断是否in，然后再list.index进行获取

   2， 判断count非零即真，-1等负数也是真，再进行获取

"""

if 1 in a_list:

   print("存在")

if 88 not in a_list:

    print("不存在list中")

 

print(a_list.index(2))  # 查询某个元素的index， 找不到的话不返回-1，直接报错

print(a_list.count(2))  # 查询某一个元素出现的次数

 

if a_list.count(22):

   print("22元素存在可以安全的获取索引：%d" % a_list.index(22))

else:

   print("元素不存在列表中")

 

 

"""

   list删除元素

   del 是一个内置函数，并不是属性， del 函数直接销毁对象

   pop 是属性，pop()默认删除最后一个，pop(1)删除索引为1的元素，并且返回该元素

   remove 是属性， pop是知道索引进行删除，remove是知道obj进行删除

   clear 清空为[]

"""

b_list = [1, 2, 3, 4]

del b_list[2]   # del b_list的话会直接删除b_list整个list，销毁对象，再print的话就话undefined

print(b_list)

 

print(b_list.pop(0))

b_list.remove(2)    # remove不存在的元素会抛异常报错

b_list.clear()

print(b_list)

 

"""

   list元素的排序

   sort() 默认无参数是从小到大

   reversed(list) 整个列表直接反过来，返回值是一个新的list

"""

import random

 

a_list = []

for i in range(10):

   a_list.append(random.randint(0, 200))

print(a_list)

a_list.sort()

print(a_list)

 

a_list.sort(reverse=True)   # 降序，从大到小

print(a_list)

 

new_list = reversed(a_list)     # [12,10,7,9] -> [9,7,10,12]

print(new_list)

 

 

"""

   一个学校，三个办公室， 八位老师进行随机分配办公室

"""

school = [[], [], []]

teacher_list = list("ABCDEFGH")

 

for name in teacher_list:

   index = random.randint(0,2)

   school[index].append(name)

print(school)

 

 

 

Python元组教程

元组没什么好说的，和数组几乎一模一样，但是它不可以被修改，也就是说，所有适用于数组修改的方法，它统统都没有。元组的主要特征是一对小括号（）。元组也有点比较特殊的地方，如果是单元素，一定要注意加上逗号，注意看下面的特例。

"""

   字符串表示："", '', """"""

  list表示：[]， 可修改

   元组的表示：(), 元组的元素不能进行修改，

   元组中如果只有一个元素的话，后面加上逗号表明是一个tuple，否则就是元素真实类型

"""

a_tuple = (1, 3.14, "Hello", True)

empty_tuple = ()

empty_tuple2 = tuple()

 

# 特例

b_tuple = (1)    # type = int

c_tuple = (1,)    # type = tuple

 

"""

   访问元组tuple

   查询的话和list一样使用count， index

"""

print(a_tuple[2])

# a_tuple[1] = "哈哈" 元组的元素不能重新赋值和修改，因为tuple是不可变的

 

print(a_tuple.count(1))    # 元组中1对象出现的次数是2， 因为Ture在计算机眼中就是1

print(a_tuple.index(3.14))

  

 

 

Python字典教程

字典这个东西在我们的现实生活中就是作查询用的，靠一个字查询到这个字的全部意思。那在python里面也差不多这个意思。一个索引词对应一个值 A: aaaaa,字典的特征有两个，第一个就是一个索引对应一个值，用冒号进行对应，第二个特征就是大括号{}。

"""

   字典数据类型dictionary表示方法： 花括号{}

"""

 

a_dict = {"name": "张三", "age": 20, "id": "007"}

print(a_dict)

b_dict = {}

c_dict = dict()

 

 

"""

   字典的常见操作

   字典的key必须是**不可变**，可以是任意类型，元组也可以为key，因为元组是不可变的

   注意字典的key必须不可变但是可以重复， 重复的话获取的是最后一个

"""

d_dict = {(1,2,3): "元组value01",

         "name": "张三",

         "info": {"address": "石家庄", "country": "中国"},

         (1,2,3): "元组value02"}

 

print(d_dict[(1,2,3)])

print(d_dict["info"]["country"])

 

"""

   字典修改元素的value, 前提是key存在，

   添加元素： 否则就会新增一个key-value

   删除元素：del python内置函数可以用在list, tuple和字典都可以用

"""

d_dict["name"] = "李四"

d_dict["name2"] = "王五"  # name2 不存在， 直接就会添加进去

del d_dict["name2"]

d_dict.clear()

print(d_dict)

 

"""

   len() 字典的长度

   keys()  返回字典中所有的key的集合, 转化为list类型

   values() 返回字典中所有的value的集合, 转化为list类型

   items()  返回的是一对对key-value以元组的形式

"""

print(len(a_dict))

print(list(a_dict.keys()))    # dict_keys(['name', 'age', 'id']) -> ['name', 'age', 'id']

print(list(a_dict.values()))

print(list(a_dict.items())[1][1])     # [('name', '张三'), ('age', 20), ('id', '007')]

 

"""

   python3中取消了字典的has_key方法，使用的是setdefault

   使用的是setdefault("key", "找不到的默认值")， 找不到的话会修改添加新的key到字典中

   get(key, 默认值) 和setdefault的作用基本一样， 但是不会添加新的key，原来dict不会变

"""

if "name" in a_dict:

   print("有一个key为name的。")

else:

   print("字典中没有一个key叫做name")

 

print(a_dict.setdefault("name1", "name的默认值"))    # 找不到name1， 添加进去

print(a_dict)

print(a_dict.get("name2", "name的默认值"))    # 找不到name2， 但是不会添加进去

print(a_dict)

 

 

"""

   字典的遍历,

"""

a_dict = {"name": "张三", "age": 20, "id": "007"}

 

for key in a_dict.keys():

   print(key)

 

for value in a_dict.values():

   print(value)

 

for item in a_dict.items():     # 遍历字典的元素，返回一个个元组（），（）

   print(item)

 

for key, value in a_dict.items():     # 遍历字典的键值对

   print(key, "->", value)

 

str1 = "xxx"

str2 = "yyy"

print(str1, str2)   # print多个变量， 第二个参数默认是一个空格：xxx yyy

print(str1, "--->", str2)   # xxx ---> yyy

 

"""

   enumerate(list / tuple等带有索引的数据结构)可以获得index

"""

a_list = ["张三", "李四", "王五"]

a_tuple = ("张三", "李四", "王五")

 

for index, temp in enumerate(a_list):

   print(index, "-->", temp)

 

 

Python集合(SET)教程

Set是python里面比较特殊的一个集合，它也是由大括号{}做成的，但是呢，它里面的元素排列和数组一样，这样{1，2，4，6}，set最特别的地方它里面的元素是不可以重复且没有顺序的，这也就间接告诉我们，他不可以直接用中括号进行取值，它可以为list进行去重。

"""

   集合set表示花括号{}， 无序不可重复,重读的话只保留一份，python自动去重操作

   add() 添加到set中， 相当于list中的append

   update(可迭代对象)， 类似于list中的extend， 将可迭代的最小单元add到set中

"""

a_set = {1,3,5,7,3}

print(a_set)       # {1, 3, 5, 7} 去重操作

 

b_set = set()

c_set = {}  # 指的是空的字典，并不是集合set类型

 

a_set.add(11)

a_set.update("abcd")

print(a_set)

 

"""

   set中的删除

   remove(obj), set无序，只能根据obj进行删除，找不到obj的话异常

   pop(), 因为set无序， 删除的并不是最后一个，而是随机的删除一个元素

   discard(), 元素存在删除， 不存在则不会发生异常

"""

a_set.remove(1)

a_set.pop()

a_set.discard(111)   # set中的discard安全一点，不会异常

print(a_set)

 

"""

   多个set集合的操作, 交集并集主要用在多个set的去重

   & -> 交集

   | -> 并集

"""

set1 = {1,2,3,4}

set2 = {3,4,5,6}

print(set1 & set2)

print(set1 | set2)

 

# 去重的话讲list转换为set的话直接迅速， 不需要手动判断

a_list = [1, 3, 4, 3, 4, 5, 6]

print(set(a_list))

 

# 利用set集合的特点，进行多个list的去重, 将每一个list转换为set求交集即可，一行代码搞定

b_list = [1, 2, 3, 4]

c_list = [3, 4, 5]

print(set(b_list) | set(c_list))

 

 

"""

   字符串， list， 元组， 字典等运算符公共方法

"""

print([1,2] + [3,4])    # [1, 2, 3, 4]

print([1,2] * 4)        # [1, 2, 1, 2, 1, 2, 1, 2]

print(3 in [1,2,3])     # True

print(3 not in [1,2,3]) # False