python基础语法【字典与字符串】

Python基础语法【字典与字符串】

一.字典

思考：定义一个变量保存一个学生的信息

stu = {'name': "小明", "sex": "男", "age": 18, "height": 189, "weight": 85, "score": 89}
print(stu["name"])
print(stu["score"])

1.列表和字典的选择

如果需要同时保存多个意义相同的数据使用列表；同时保存多个意义不同的数据就使用字典。

2.什么是字典（dict）

a.字典是容器型数据类型;将{}作为容器的标志，里面多个键值对（元素）用逗号隔开：{键1：值1， 键2：值2…}
b.字典是可变的(支持增删改)；字典是无序的(顺序不影响结果，不支持下标操作)；
c.注意：都是英文状态下输入
d.字典的元素：
1）元素必须是键值对；
2）键必须是不可变的类型的数据（字符串、数字、布尔、元组等，一般使用字符串作为键）；
3）键是唯一的；
4）值可以是任何类型的数据；

2.1空字典

d1 = {}

2.2字典是无序的

print({"a": 10, "b": 20} == {"b": 20, "a": 10})

2.3字典的键必须是不可变类型的数据

d2 = {"a": 10, 20: 30, 1.2: 40, (10, 20): 50}
#d2 = {"a": 10, 20: 30, 1.2: 40, [10, 20]:} 报错

2.4键是唯一的

d3 = {"a": 10, "a": 100, "b": 20}
print(d3)  # {"a": 100, "b": 20 }自动保存后面的数据

2.5值可以是任何类型的数据

stu = {'name': "小明", "sex": "男", "age": 18, "height": 189, "weight": 85, "score": 89}
class1 = {
    "name": "python2301",
    "teacher": {"name": "ting", "age": 18, "tel": 12345678},
    "students": [
        {"name": "A", "age": 18, "tel": 123456},
        {"name": "B", "age": 20, "tel": 789626}
    ]#只有三个键值对
}

二.字典的增删改查

2.1.查 —— 获取字典的值

1）查单个 —— 获取某一个值

语法：字典[键] —— 获取字典中指定键对应的值

dog = {"name": "来福", "age": 3, "breed": "金毛", "color": "yellow", "prince": 2000}
print(dog["breed"])
print(dog["prince"])

2）
a.字典.get(键) —— 获取字典中指定键对应的值，如果键不存在返回None
b.字典.get(键，默认值) —— 获取字典中指定键对应的值；存在则返回原有的值，如果不存在就返回默认值

print(dog.get("age"))
print(dog.get("name"))
print(dog.get("weight"))  # None

print(dog.get('name', '无名氏'))  # 如果说已经存在，那么就直接返回得到是已经存在的值
print(dog.get('weight', 0))  # 如果是不存在的值，那么返回0

2.真正的字典 —— 生活的角度看数据
案例： 定义一个变量保存一个班级的信息

class1 = {
    'name': 'python2301',
    'teacher': {'name': '余婷', 'age': 18, 'tel': '13678192302'},
    'students': [
        {'name': 'stu1', 'age': 19, 'school': '清华大学', '专业': '经济', 'contact': {'name': '张三', 'tel': '110'}},
        {'name': 'stu2', 'age': 28, 'school': '北京大学', '专业': '大数据', 'contact': {'name': '李四', 'tel': '192'}},
        {'name': 'stu3', 'age': 22, 'school': '厦门大学', '专业': '计算机', 'contact': {'name': '王五', 'tel': '920'}},
        {'name': 'stu4', 'age': 17, 'school': '南京大学', '专业': '物联网', 'contact': {'name': '赵六', 'tel': '2833'}},
    ]
}

# 1)获取班级名称
print(class1["name"])
# 2）获取讲师的名字
print(class1["teacher"]["name"])
# 3）获取所有学生的名字和对应的学校
for stu in class1["students"]:  # 每一个学生对应的字典
    print(stu["name"], stu["school"])
# 4）获取未成年学生的名字
for stu in class1["students"]:
    if stu["age"] < 18:
        print(stu["name"])
# 5）获取第一个学生的联系人的电话
print(class1["students"][0]["contact"]["tel"])
# 6）获取所有学生的联系人的电话
for stu in class1["students"]:
    print(stu["contact"]["tel"])

2）遍历字典

for 变量 in 字典：
    循环体（变量依次获取得是字典所有的键）

dog = {"name": "来福", "age": 3, "breed": "金毛", "color": "yellow", "prince": 2000}
for key in dog:
    print('key:', key, 'value:', dog[key])

2.2.增、改

1)字典[键] = 值 ——当键存在的时候，就修改这个键对应的值；当键不存在的时候，就添加键值对
2）字典.setdefault(键,值) —— 添加键值对（键不存在就添加，存在的话不会修改）

1. 语法1：

   dog = {"name": "来福", "age": 3, "breed": "金毛", "color": "yellow", "prince": 2000}
   print(dog)
   dog["name"] = "小花"  # 字典中存在，就修改
   print(dog)  # {'name': '小花', 'age': 3, 'breed': '金毛', 'color': 'yellow', 'prince': 2000}
   dog["sex"] = "母狗"  # 字典中不存在，就增加
   print(dog)  # {'name': '小花', 'age': 3, 'breed': '金毛', 'color': 'yellow', 'prince': 2000, 'sex': '母狗'}
   

2. 语法2：

   dog = {"name": "来福", "age": 3, "breed": "金毛", "color": "yellow", "prince": 2000}
   dog.setdefault("name", "大黄")
   print(dog)
   dog.setdefault("sex", "母狗")
   print(dog)
   

3）案例：给所有没有折扣的商品添加discount的值为1

goods_list = [
    {'id': 'g001', 'price': 89, 'count': 100},
    {'id': 'g001', 'price': 207, 'count': 50, 'discount': 0.9},
    {'id': 'g001', 'price': 102, 'count': 33},
    {'id': 'g001', 'price': 25, 'count': 897, 'discount': 0.88}
]
for x in goods_list:
    x.setdefault("discount", 1)  # 把没有折扣的商品添加discount的值为1
print(goods_list)

2.3.删——删除键值对

1）del 字典[键] ——删除字典中指定键对应的键值对
2）字典.pop(键) ——取走字典中指定键对应值

3）例子1：用del 字典[键]

dog = {"name": "来福", "age": 3, "breed": "金毛", "color": "yellow", "prince": 2000}
print(dog)
del dog["name"]
print(dog) 
# {'age': 3, 'breed': '金毛', 'color': 'yellow', 'prince': 2000}

4）例子2：用字典.pop(键)

dog = {"name": "来福", "age": 3, "breed": "金毛", "color": "yellow", "prince": 2000}
dog.pop("age")
print(dog)  # {'breed': '金毛', 'color': 'yellow', 'prince': 2000}
result = dog.pop("color")
print(dog, result)  # {'breed': '金毛', 'prince': 2000} yellow

2.4.字典的相关操作

1）in 和 not in
a.键 in 字典 ——字典中是否存在指定的键对应的键值对

d1 = {"a": 10, "b": 20}
print(10 in d1)  # False
print("a" in d1)  # True

2）字典不支持加法运算、乘法运算和比较大小

2.5.字典的相关函数

1）len(字典) —— 获取字典的长度

print(len(dict1))

2）dict(数据) —— 将指定的数据类型转换成字典；

对数据的要求：
a.数据必须是一个序列（容器）
b.序列中的每个元素必须是有且只有两个元素的小序列

data1 = [[10, 20], [30, 20], ['a', 20]]
print(dict(data1))  # {10: 20, 30: 20, 'a': 20}

print(dict(['ab', 'vd', 'gh']))  # {'a': 'b', 'v': 'd', 'g': 'h'}

print(dict(['ab', [10, 20], range(2)]))  # {'a': 'b', 10: 20, 0: 1}

print(dict([('name', '小明'), ('age', 18), ('sex', "男")]))  # {'name:': '小明', 'age': 18, 'sex': '男'}

3)list(字典) —— 将字典转换成列表的时候，是将字典中所有的键作为列表的元素;

dict1 = {'name:': '小明', 'age': 18, 'sex': '男'}
print(list(dict1))  #['name:', 'age', 'sex']

2.6 字典相关方法——字典.xxx()

1)字典.clear() —— 清空字典
2)字典.copy() —— 复制字典产生一个一模一样的新的字典并且返回
3)字典，keys() —— 获取字典所有的键，返回一个序列
4)字典.items() —— 将字典转成一个序列，序列中的元素是每个键值对对应的元组
5)字典.values() —— 获取字典所有的值，返回一个序列

print(dict1.keys())  #dict_keys(['name:', 'age', 'sex'])
print(dict1.values())  #dict_values(['小明', 18, '男'])
print(dict1.items())  #dict_items([('name:', '小明'), ('age', 18), ('sex', '男')])

6)字典1.update(字典2) —— 将字典2中所有的键值对都添加到字典1中;

dict1 = {'name:': '小明', 'age': 18, 'sex': '男'}
dict1.update({"score":100,'tel':'123'})
print(dict1)  # {'name:': '小明', 'age': 18, 'sex': '男', 'score': 100, 'tel': '123'}

三.字符串

3.1.字符串（str）

3.1.1初识字符串

1)字符串是容器型数据类型(能同时保存多个文字符号)：将单引号、双引号或者三个单引号、三个双引号作为容器的标志
2)字符串不可变；字符串有序
3) 字符串的元素：
字符串引号中每一个独立的符号都是字符串的元素，字符串的元素又叫字符；
任何文字符号都可以是字符串的元素（包括英文符号、中文符号、阿拉伯数字、韩语、日语、…表情符号）

3.1.2 字符串

1)字符串是容器型数据类型，可以同时保存多个文字符号；将单引号或者双引号作为容器的标志，引号中的每个符号就是字符串中的每个元素。
2)字符串是不可变的；字符串是有序的；
3)元素：引号中的每个独立的符号（字符串的元素又叫字符）；
可以是任何国家任何民族的任何语言的符号，还可以是转义字符；
4)转义字符 —— 在特定的符号前加 ”\“ 来表示特殊功能或者特殊意义的符号；

            \n——换行(相当于按回车)
            \t——水平制表符（相当于按了一个tab键）
            \'——表示一个普通的单引号
            \"——表示一个普通的双引号
            \\——表示一个普通的反斜杠

5）普通字符 —— 在字符串中表示符号本身的字符就是普通字符；
5）例子：

str1 = "a,b,c"  # 有五个——a   ,   b  ,  c
print("abc" == "cba") #False
str2 = "abc你好"
print(str2)
str3 = "abc\n你好"
print(str3)
str41 = "it's me"  # 双引号
str42 = 'it\'s me'  # 单引号
print(str41)
print(str42)
str5 = 'I say:"good good study, day day up"'
str5 = "I say:\"good good study, day day up\""
print(str5)

6).r字符串
在字符串的引号前面加r或者R，可以让字符串中所有的转义字符功能消失（让所有字符都变成普通字符）

str1 = r'\tabc\n123'
print(str1)  #\tabc\n123

path = r'C:\Users\Administrator\Pictures\Saved Pictures'
print(path)  #C:\Users\Administrator\Pictures\Saved Pictures

3.1.3 字符编码

1.计算机存储数据只能存数字（存的是数字的二进制补码）

为了能够让计算机存储文字符号，给每个符号对应了一个固定的数字，每次在需要存储这个符号的时候，就去存储这个固定的数字。
每个对应的那个数字就是这个符号的编码值。

3.1.4 编码表 —— 保存字符和字符对应编码值的表

1）ASCII码表
美国信息码（只包含了美国人常用的符号，总共128）
数字字符：0~9
大写字母A~Z（A-65）和小写字母a~z（a~97）
英文输入法下的特殊符号

2）Unicode编码表(python) —— 包含了世界上所有的国家所有的民族的所有的语言符号
Unicode编码表包含了Ascii（前128个字符就是ascii码表中的内容）
中文编码范围：4e00 ~ 9fa5

3.1.5编码值的应用

1)chr(编码值) —— 获取编码值对应的字符

print(chr(97))  # a
print(chr(0x4e00))  # 一(十六制需要在以0x开头)
print(chr(0x9fa5))  # 龥
print("__________________________华丽的分割线_________________________")
from pypinyin import pinyin

print(pinyin('龥'))  # [['yù']]
print("__________________________华丽的分割线_________________________")

2）ord(字符) —— 获取指定字符对应的编码值
注意： 字符指的是长度为1的字符串，返回编码值是十进制

print(ord('a'))  # 97
print(ord('张'))  # 24352
print(ord('婷'))  #

将char对应的小写字母转化成大写字母 ,大写字母和小写字母差值为32;大写转换小写加32;

char = 'm'
print(chr(ord(char) - 32))  # M

# 大写转换小写加32
char = 'M'
print(chr(ord(char) + 32))  # m

3）编码字符：\u 4位的16进制编码值

# 在字符串中提供字符的方式有两种：a.直接提供字符 b.使用编码字符

# hex(10进制数) —— 获取指定数字对应的16进制表示方式

# 如果知道字符编码值是多少，但是不知道字符是什么的时候，就可以使用编码字符来表示这个字符

str2 = '\u0061\u9fa5'
print(str2)  # a龥

# 方法1：
char = 'j'
if '一' <= char <= '龥':
    print(char, '是中文')
else:
    print(char, "不是中文")

# 使用编码字符方法：
char = 'j'
if '\u4e00' <= char <= '\u9fa5':
    print(char, '是中文')
else:
    print(char, "不是中文")

3.2. 查 ——获取字符

1）查单个：字符串[下标]——获取指定下标对应的元素

str1 = "\thello world!"
print(len(str1))  # 查看字符串长度
print(str1[1])  # h
print(str1[2])  # e

2) 字符串切片——字符串[开始下标：结束下标：步长]

str1 = 'good good study!'
print(str1[1:-2:2])  # 'odgo td'
print(str1[-3:])  # dy!
str2 = '你真棒！'
print(str2[0:2])  # 你真

print(str2[::])  # 你真棒！

3) 遍历

语法：

a.
for 变量 in 字符串：
    循环体
b.
for 变量 in range(len(字符串))：
    循环体
c.
for index, item in enumerate(str1):
    print(index, item)
d.
for index,item in enumerate(str2):
    print(index,item) 

例子：

for x in "abc123":
    print(x)

str1 = 'abc123'
for x in range(len(str1)):
    print(x, str1[x])

3.3.字符串相关操作

1）字符串加法运算

a.字符串1 + 字符串2 —— 将两个字符串合并产生一个新的字符串;

str1 = 'hello'
str2 = 'python'
str3 = str1 + " " + str2
print(str3)  # hello python

b.案例：已知在字符串str4中的每个字符后面添加一个*；str4 = “abc” ——> "abc*“

str4 = "abc"
new_str4 = ''
for x in str4:
    new_str4 += x + "*"
print(new_str4)

2)字符串乘法运算

a.字符串 * N、N * 字符串 —— 将字符串中的元素重复n次产生一个新的字符串;

str1 = "hello"
print(str1 * 3)

3)字符串比较运算

a.比较第一对不相等的字符的大小（两个字符比较大小比较的是字符的编码值大小）

print("abc" > "acb")  # "b" < "c" False
print('a123b' > "abc")  # "1" > "b" False
print("你好" > "abc")  # "你" > "a" True

b.已知字符x：
判断x是否是数字字符：‘0’ <= x <= ‘9’;
判断x是否是小写字母：‘a’<= x <= ‘z’;
判断x是否是大写字母：“A”<= x <= ‘Z’;
判断x是否是字母：‘A’ <= x <= ‘Z or ‘a’<= x <= ‘z’。
判断是否是中文：’\u4e00’ <= x <= ‘\u9fa5’

c. 案例：提取字符串中所有的数字字符，str1 = “sgehhu21274你好”。

str1 = "sgehhu21274你好"
new_str1 = ''
for x in str1:
    if "0" <= x <= '9':
        new_str1 += x
print(new_str1)

4）in 和 not in

a.字符串1 in 字符串2 —— 判断字符串1是否字符串2的子串（判断字符串2中是否包含字符串1）

b.例子1

list1 = [10, 20, 30, 40]
print(10 in list1)  # true
print([10, 20] in list1)  # false

c.例子2

str1 = "abc123"
print("a" in str1)  # true
print("ab" in str1)  # true
print("ac" in str1)  # false

3.4 字符串相关函数

1）max，min，sorted

print(max('hello world!'))  # 'w'
print(sorted("hello world!"))  # [' ', '!', 'd', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']

2)len(字符串)

msg = "\thello\nworld!\u4e00"
print(len(msg))

3)转换成字符串——str(数据) :
str(数据) —— 任何数据都可以转换成字符串；转换的时候是在数据的打印值外面加引号。

str(100)  # ‘100’
str(1.23)  # "1.23"
str(True)  # "True"

list1 = [10, 20, 30, 40]
str(list1)  # '[10, 20, 30, 40]'

list1 = ["bob", 19]
print(str(list1))  # "['bob', 19]"

4）eval(字符串) —— 去掉字符串的的引号，获取引号中表达式的结果

a = eval('100')  # 100
b = eval('1.23')  # 1.23

abc = 123
c = eval('abc')  # abc
d = eval('hello')  # d = "hello"

a1 = eval("[10, 20, 30]") # a1 = [10, 20, 30]
print(a1)
a1.append(100)
print(a1)  # [10,20,30,100]

b1 = eval("10 + 10") # b1 = 10 +10
print(b)
print("__________________________华丽的分割线_________________________")

a = int(input('请输入100：'))
b = int(input('请输入100：'))
val = input("请输入指令：")
result = eval(val)
print(result)

3.5字符串相关方法

1.字符串.join() —— 将序列中的元素用指定的字符串连接成一个新的字符串(序列)

list1 = ["小明", "张三", '李四', '王五']
result = '+'.join(list1)
print(result)  # 小明+张三+李四+王五

result1 = 'and'.join(list1)
print(result1)  # 小明and张三and李四and王五

result = '**'.join("abc")
print(result)  # a**b**c

# 注意：序列中的元素必须是字符串
nums = [90, 78, 67, 56, 45]
result = "+".join([str(x) for x in nums])
print(result)  # 90+78+67+56+45

2.字符串1.count(字符串2) —— 统计字符串1中字符串2的个数。

msg = "how are you?"
result = msg.count('o')
print(result)  # 2
print(msg.count('you'))  # 1

3.字符串1.split(字符串2)

1）字符串1.split(字符串2)—— 将字符串1中所有的字符串2作为切割点对字符串1进行切割;
2) 字符串1.split(字符串2,N) —— 将字符串1中前N个字符串2作为切割点对字符串1进行切割;

msg = 'how are you? i am fine! thank you, and you?'
result = msg.split('you')
print(result)  # ['how are ', '? i am fine! thank ', ', and ', '?']
result = msg.split(' ')
print(result)  # ['how', 'are', 'you?', 'i', 'am', 'fine!', 'thank', 'you,', 'and', 'you?']

result = msg.split(' ', 3)
print(result)  # ['how', 'are', 'you?', 'i am fine! thank you, and you?']

4.字符串1.replace(字符串2,字符串3)

1）字符串1.replace(字符串2,字符串3) —— 将字符串1中所有的字符串2都替换成字符串3;
2）字符串1.replace(字符串2,字符串3,N) —— 将字符串1中前N个字符串2都替换成字符串3;

msg = 'how are you? i am fine! thank you, and you?'
result = msg.replace('you', 'me')
print(result)  # how are me? i am fine! thank me, and me?

result = msg.replace('you', '')
print(result)  # how are ? i am fine! thank , and ?

result = msg.replace('you', '+', 2) # 只替换前两个
print(result)  # how are +? i am fine! thank +, and you?

5.字符串.strip() —— 去掉字符串前后的空白字符

msg = '                                                                                                            how are you? i am fine! thank you, and you?                                                                         '

result = msg.strip()
print(msg.strip())

6.字符串.isupper()

1）字符串.isupper() —— 判断字符串是否是纯大写字母字符串；
2）字符.isupper() —— 判断字符是否是大写字母；

print('JHDGF'.isupper()) # True
print('J'.isupper())  # True

7.字符串.islower() —— 判断字符串是否是纯小写字母字母

print('a'.islower()) # True

8.字符串.isdigit() —— 判断字符串是否全是数字字符

print(‘123’.isdigit())

9.字符串.upper() —— 将字符串所有的小写都改成大写字母

print('jish2324dsdssf'.upper())  # JISH2324DSDSSF

10.字符串.lower() —— 将字符串所有的大写都改成小写字母

print('JHDGF'.lower())  # jhdgf

 案例：判断char是否是字母
char = 'M'
if char.islower() or char.isupper():
    print('是字母')
else:
    print("不是字母")
print("__________________________华丽的分割线_________________________")
if 'A' <= char <= 'Z' or 'a'<= char <= 'z':
    print('是字母')
else:
    print("不是字母")