python字符名称 python中字符类型

阅读目录

一 数据

二 数字

三 字符串

四 列表

五 元组

六 字典

七 集合

八 数据类型总结

九 运算符

十 字符编码

十一 文件处理

一 数据

1 . 数据

x=10，10是我们要存储的数据

数据

2. 为何要分为不同类型

数据是用来表示状态的，不同的状态就应该用不同的类型的数据去表示

为什么要分不同数据类型

 

3. 数据类型

数字（整形，长整形，浮点型，复数）

字符串

字节串：在介绍字符编码时介绍字节bytes类型

列表

元组

字典

集合

数据类型分类

 

4. 如何学习数据类型

#一：基本使用
1 用途

2 定义方式

3 常用操作+内置的方法

#二：该类型总结
1 存一个值or存多个值
    只能存一个值
    可以存多个值，值都可以是什么类型

2 有序or无序

3 可变or不可变
    ！！！可变：值变，id不变。可变==不可hash
    ！！！不可变：值变，id就变。不可变==可hash

学习数据类型

 

二 数字

1. 整形和浮点型

#整型int
　　#作用：年纪，等级，身份证号，qq号等整型数字相关
　　#定义：
　　　　age=10 #本质age=int(10)
            print(id(x),type(x),x)

#二：float
#作用：工资，身高，体重
salary=3.1 #salary=float(3.1)
print(id(salary),type(salary),salary)

整形和浮点型

 

2. 其他数字类型

#长整形（了解）
    在python2中（python3中没有长整形的概念）：　　　　　　
    >>> num=2L
    >>> type(num)
    <type 'long'>

#复数（了解）　　
    >>> x=1-2j
    >>> x.real
    1.0
    >>> x.imag
    -2.0

其他数字类型

 

三 字符串

1. 字符串

 

1 #用途：名字，性别，地址
2 # name='egon' #name=str('egon')
3 # print(id(name),type(name),name)

字符串

 

#优先掌握的操作
# 按照索引取值（正向取值和反向取值）：只能取
name='egon' #name=str('egon')
print(name[0],type(name[0]))
print(name[-2])
print(name[-1])
name[0]='E'

取值 *

 

#切片（顾头不顾尾，步长）
msg='hello world'
print(msg[1:3])
print(msg[1:7:3])

msg='abcdefg'
print(msg[1:6:2])
print(msg[:]) #取所有
print(msg[::2])#取所有，步长为2
print(msg[6::-1])#了解，倒取所有。

切片（顾头不顾尾，步长） *

 

#长度(len)
msg='ab c'
print(len(msg))

长度（len） *

 

#成员运算in和not in
msg='hello alex'
print('a' in msg)
print('alex' in msg)
print('ae' in msg)  #必须是连续的字符

成员运算in 与 not in *

 

#移除空白strip
password='alex3714    '
# password=password.strip()
# print(password) #简化为
print(password.strip())#取出空格

msg='****egon***'
print(msg.strip('*'))#去除两端，字符串中间不去。

移除空白strip *

 

#切分split
user_info='root:x:0:0::/root:/bin/bash'
print(user_info.split(':')[0])

cmd='put a.txt'
print(cmd.split()[0])#默认以空格为分隔符。

flit='put /a/b/c/d/a.txt'
print(flit.split('/',1))#以'/'为分隔符，切分一次。

切分split *

 

#在python3中
num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字

#isdigt:bytes,unicode
print(num1.isdigit()) #True
print(num2.isdigit()) #True
print(num3.isdigit()) #False
print(num4.isdigit()) #False

isdigt ，判断字符串中只有单纯数字组成 *

 

 

msg='***alex****'
print(msg.strip('*'))
print(msg.lstrip('*'))
print(msg.rstrip('*'))

trip与lstrip与rstrip 清楚空白 *

 

#startswith与endswith ，以什么开头与以什么结尾。
msg='alex_SB'
print(msg.startswith('alex')) #以什么开头
print(msg.endswith('SB')) #以什么结尾

startswith与endswith ，以什么开头与以什么结尾 *

 

#replace ，替换字符
msg='alex say i have on telsa,my name is alex'
print(msg.replace('alex', 'sb',1))#替换某个字符串

replace ，替换字符 *

 

#format ，占位
print('my name is %s my age is %s'%('egon',18))
print('my mame is {} my age is {}'.format('egon',18))#占位符
print('{0} {0} {1}'.format('egon',18))
print('my mame is {x} my age is {y}'.format(x='egon',y=18))

format ，占位 *

 

#find,rfind,index,rindex,count，查找字符串位置
msg='hello world'
print(msg.find('ell')) #查找字符串的子字符串，有返回第一个的索引。
print(msg.find('x'))#没有返回-1.
print(msg.index('w'))#查找字符串的子字符串，有返回第一个的索引。
#print(msg.index('x'))#找不到，报错
print(msg.count('l',0,4))#统计子字符串的个数

find,rfind,index,rindex,count，查找字符串位置

 

#join,还原切分的字符创
uesr_info='root:x:0:0:: asdfdff'
l=uesr_info.split(':')
print(':'.join(l))
print(''.join(l))

join,还原切分的字符创

 

#center,ljust,rjust,zerofill ,居中显示，左对齐，右对齐，以0填充占位
print('egon'.center(30,'='))
print('egon'.ljust(30,'='))
print('egon'.rjust(30,'='))
print('egon'.zfill(30))

center,ljust,rjust,zerofill ,居中显示，左对齐，右对齐，以0填充占位 *

 

msg='abc\tdeft' #制表符
print(msg.expandtabs(3))

制表符

 

msg='alex Say hello'
print(msg.capitalize()) #首字母大写
print(msg.upper()) #全部大写
print(msg.lower())#全部小写
print(msg.title())#所有首字母大写
print(msg.swapcase())#大小写字母转换

字母大小写

 

# #is 系列
msg='Alex Say Hello'
print(msg.isupper()) #必须全部是大写
print(msg.islower())#必须全部是小写
print(msg.istitle())#必须首字母全部是大写


msg='abc'
print(msg.isalpha())#只能包含字母
msg='abc123'
print(msg.isalnum())#字符串是有字母或数字组成


msg='   1'
print(msg.isspace())#是否是全部是空格组成
msg='ifaaa'
print(msg.isidentifier()) #是否含有判读的关键字

is 系列

 

#is数字系列
#在python3中
num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字

#isdigt:bytes,unicode
print(num1.isdigit()) #True
print(num2.isdigit()) #True
print(num3.isdigit()) #False
print(num4.isdigit()) #False


#isdecimal:uncicode
#bytes类型无isdecimal方法
print(num2.isdecimal()) #True
print(num3.isdecimal()) #False
print(num4.isdecimal()) #False

#isnumberic:unicode,中文数字,罗马数字
#bytes类型无isnumberic方法
print(num2.isnumeric()) #True
print(num3.isnumeric()) #True
print(num4.isnumeric()) #True


#三者不能判断浮点数
num5='4.3'
print(num5.isdigit()) 
print(num5.isdecimal())
print(num5.isnumeric())
'''
总结:
    最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
    如果要判断中文数字或罗马数字,则需要用到isnumeric
'''

isdigt ，判断字符串中只有单纯数字组成

 

2. 练习

#练习
name = " aleX"
# 1)    移除 name 变量对应的值两边的空格,并输出处理结果
print(name.strip())
# 2)    判断 name 变量对应的值是否以 "al" 开头,并输出结果

print(name.startswith('al'))
# 3)    判断 name 变量对应的值是否以 "X" 结尾,并输出结果

print(name.endswith('X'))
# 4)    将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
print(name.replace('l','p'))
# 5)    将 name 变量对应的值根据 “l” 分割,并输出结果。
print(name.split('l'))
# 6)    将 name 变量对应的值变大写,并输出结果

print(name.upper())
# 7)    将 name 变量对应的值变小写,并输出结果

print(name.lower())
# 8)    请输出 name 变量对应的值的第 2 个字符?
print(name.strip()[1])
# 9)    请输出 name 变量对应的值的前 3 个字符?
print(name.strip()[0:4])
# 10)    请输出 name 变量对应的值的后 2 个字符?

print(name.strip()[-2:])
# 11)    请输出 name 变量对应的值中 “e” 所在索引位置?

print(name.find('e'))
# 12)    获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。
print(name.strip()[:-1])

练习

 

四 列表

1. 列表

作用：多个装备，多个爱好，多门课程，多个女朋友等

#定义：[]内可以有多个任意类型的值，逗号分隔
my_girl_friends=['alex','wupeiqi','yuanhao',4,5] #本质my_girl_friends=list([...])
或
l=list('abc')

#优先掌握的操作：
按索引存取值(正向存取+反向存取)：即可存也可以取      
切片(顾头不顾尾，步长)
长度
成员运算in和not in


追加
删除
循环

列表

 

my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
print(my_girl_friends[2]) #正取
print(my_girl_friends[-1])#反取
print(id(my_girl_friends))
my_girl_friends[0]='SB' #存值
print(id(my_girl_friends))

取值存值 *

 

my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
print(my_girl_friends[0:2])#取前两个
print(my_girl_friends[0:4:2])#步长为2

切片（顾头不顾尾，步长） *

 

my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
print(len(my_girl_friends))

长度 len *

 

my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
print('alex' in my_girl_friends)

成员运算in 和not in *

 

my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
my_girl_friends.append('6号')
print(my_girl_friends)

追加 append *

 

#删除
my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
del my_girl_friends[2] #删除任意类型的值
print(my_girl_friends.remove('yuanhao'))#remove 只是单纯删除，不会返回删除的值。并且按照值去删
my_girl_friends.pop()#按照索引删除，默认从末尾删除
print(my_girl_friends)

删除 remove与pop *

 

my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
my_girl_friends.insert(2,'sb_alex')
print(my_girl_friends)

插入单个元素 insert *

 

#extend
my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
my_girl_friends.extend([1,2,3,4,5]) #插入多个元素
print(my_girl_friends)

插入多个元素 extend *

 

#count 统计元素
my_girl_friends=['alex','wupeiqi','alex','yuanhao',4,5]
print(my_girl_friends.count('alex'))

统计元素 count *

 

#clear 清除所有元素
my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
my_girl_friends.clear()
print(my_girl_friends)

清理所有元素 clear 

 

#copy 拷贝
my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
my_girl_friends.copy()
print(my_girl_friends)

拷贝 copy

 

#翻转 reverse
my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
my_girl_friends.reverse()
print(my_girl_friends)

翻转 reverse

 

#排序 sort
l=[3,1,2,4]
l.sort()  #排序
l.sort(reverse=True)# 排序翻转
print(l)

排序 sort

 

#队列：先进先出,案例：坐扶梯
#append ,pop
l=[]
l.append('first')
l.append('second')
l.append('three')
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))

#堆栈：先进后出，案例：叠衣服往箱子里放
#insert，pop
n=[]
n.insert(0,'first')
n.insert(0,'second')
n.insert(0,'three')
print(n.pop(0))
print(n.pop(0))
print(n.pop(0))

队列与堆栈 *

 

#1. 有列表data=['alex',49,[1900,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量
data=['alex',49,[1900,3,18]]
name=data[0]
print(name)
age=data[1]
print(age)
year=data[2][0]
print(year)
months=data[2][1]
print(months)
day=data[2][2]
print(day)

练习

 

五 元组

1. 元组

#作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读
#定义方式：
ages=(10,12,18,33,18) #ages=tuple((10,12,18,33))
# print(id(ages),type(ages),ages)

元组

 

#按照索引（正向取和反向取）：只能取
ages=(10,12,18,33,18)
print(ages[0])
print(ages[-1])

取值 *

 

#切片（顾头不顾尾，步长）
ages=(10,12,18,33,18)
print(ages[1:3])
print(ages[1:4:2])

切片 *

 

#长度 len
ages=(10,12,18,33,18)
print(len(ages))

长度 len *

 

#成员运算in 和 not in
ages=(10,12,18,33,18)
print(10 in ages)

成员运算 *

 

ages=(10,12,18,33,18)
print(ages.index(18))# 查找元素的索引

定位元素的索引 index *

 

ages=(10,12,18,33,18)
print(ages.count(18))#统计元组中元素的个数

统计元组中元素的个数 count *

2. for ...in  

l=['a','b','c','d']
l='abcdef'
l=('a','b','c','d','f')
index=0
while index < len(l):
    print(l[index])
    index+=1

利用while 根据索引在字符串、列表、元组里取值 *

 

l=['a','b','c','d']
for item in l:
    print(item)

l=['a','b','c','d']
for i in range(len(l)):
    print(i,l[i])

用 for.....range取字符串、列表、元组的索引与元素 *

 

l=['a','b','c','d']
for i in range(len(l)):
    print(i,l[i])

用 for.....range取字符串、列表、元组的索引与元素 *

 

msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
for key in msg_dic:
    print(key,msg_dic[key])

用for...in 循环在字典里取值 *

 

#for + else
for i in range(5):
    if i == 3:break
    print(i)
else:
    print('ok')

for....else

 

 

3. 练习

实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入　　

msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
} 
goods_l=[]

while True:
    for key in msg_dic:
        print(key,msg_dic[key])
    choice=input('请输入商品名称：').strip()
    if choice not in msg_dic:
        continue
    count = input('请输入商品个数：').strip()
    if count.isdigit():
      goods_l.append((choice,msg_dic[choice],int(count)))
    print(goods_l)

打印购物车菜单

 

六 字典

1. 字典

#作用：存多个值,key-value存取，取值速度快

#定义：key必须是不可变类型，value可以是任意类型
d={'a':1}
d={0:1}
d={[1,2,3]:1} #列表不能当做字典的key
d={(0,'mac'):3000}

print(d[(0,'mac')])

info={'name':'egon','age':18,'sex':'male'} #本质info=dict({....})

字典

 

#按照key存取值：可存可取
info={'name':'egon','age':18,'sex':'male'}
print(info['name'])#取
info['hobbies']=['read','music','play']# 存
print(info)

存取

 

#长度 len  ,统计简直对的个数
info={'name':'egon','age':18,'sex':'male'}
print(len(info))

长度len ,统计键值对的个数

 

#成员运算in 和 not in
info={'name':'egon','age':18,'sex':'male'}
print('name' in info)

成员运算in 和 not in

 

#删除
info={'name':'egon','age':18,'sex':'male'}
print(info.pop('name'))
print(info.pop('name1222',None)) #没有返回None

删除 pop  返回value

 

# # 键keys()，值values()，键值对items()
print(info.keys())
print(info.values())
print(info.items())


for key in info.keys():
    print(key)

for val in info.values():
    print(val)

for item in info.items():
    print(item[0],item[1])

键keys()，值values()，键值对items()

 

 

#补充两种赋值方式：
#一：链式赋值
x=10
y=x
x=y=z=10
print(id(x),id(y),id(z))


#交换两个变量的值
m=10
n=20
temp=n
n=m #n=10
m=temp
print(m,n)
m,n=n,m
print(m,n)

#二：从一个数据类型中解压出我们想要的值
t=(10.3,11.2,12.1,14.3,3.1)

x,y,z,a,b=t
print(x,y,z,a,b)

x,_,_,_,b=t
print(x,b)
print(_)

x,*_,b=t
print(x,b)


x,*_='hello'
print(x)

x,y,z={'a':1,'b':2,'c':3}
print(x,y,z)

两种赋值方式：赋值与解压

 

info={'name':'egon','age':18,'sex':'male'}
for k,v in info.items(): #k,v=('name', 'egon')
     print(k,v)

解压 取值

 

info={'name':'egon','age':18,'sex':'male'}
print(info.get('name'))
print(info.get('name123'))#key不存在，返回None

取值 get ,key 值不存在返回None

 

info={'name':'egon','age':18,'sex':'male'}
print(info.popitem())

删除 popitem 返回键值对

 

info={'name':'egon','age':18,'sex':'male',}
info_new={'a':1,'age':19}
info.update(info_new)
print(info)

更新 update ,没有的添加，有的覆盖

 

dic={'name':None,'age':None,'sex':None,'hobbies':None}
dic1={}.fromkeys(['name','age','hobbies'],None)
print(dic1)

初始化字典 fromkeys

 

info={'name':'egon','age':18,'sex':'male',}
print(info.setdefault('hobbies',['read','music'])) #有则不改，返回已经有的值，没有则新增，返回新增的值
print(info)

print(id(info.setdefault('hobbies',[])))
print(id(info['hobbies']))

if 'hobbies' not in info:
    info['hobbies']=[]
    info['hobbies'].append('music')
else:
    info['hobbies'].append('read')

if 'hobbies' not in info:
    info['hobbies'] = []
    info['hobbies'].append('music')
else:
    info['hobbies'].append('read')

print(info)

info.setdefault('hobbies',[]).append('music')

# {'name': 'egon', 'age': 18, 'sex': 'male', 'hobbies': ['music', ]}
info.setdefault('hobbies',[]).append('read') #['music', ].append('read')
print(info)

赋值 setdefault ，有则不改，返回已经有的值，没有则新增，返回新增的值

 

1 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中

即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}


numer=[11,22,33,44,55,66,77,88,99]
l={'k1':[],'k2':[]}
for i in numer:
   if i > 66:
      l['k1'].append(i)
   else:
       l['k2'].append(i)
print(l)

练习1

 

2 统计s='hello alex alex say hello sb sb'中每个单词的个数

结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}
#方法一
s='hello alex alex say hello sb sb'

l=s.split()
dic={}
for item in l:
    if item in dic:
        dic[item]+=1
    else:
        dic[item]=1
print(dic)

#方法二：
复制代码
s='hello alex alex say hello sb sb'
dic={}
words=s.split()
print(words)
for word in words: #word='alex'
    dic[word]=s.count(word)
    print(dic)

#方法三：
#利用setdefault解决重复赋值
'''
setdefault的功能
1：key存在，则不赋值，key不存在则设置默认值
2：key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值
d={}
print(d.setdefault('a',1)) #返回1

d={'a':2222}
print(d.setdefault('a',1)) #返回2222
'''
s='hello alex alex say hello sb sb'
dic={}
words=s.split()
for word in words: #word='alex'
    dic.setdefault(word,s.count(word))
    print(dic)
#方法四：
#利用集合，去掉重复，减少循环次数
s='hello alex alex say hello sb sb'
dic={}
words=s.split()
words_set=set(words)
for word in words_set:
    dic[word]=s.count(word)
    print(dic)

练习二

 

 七 集合

1. 集合

pythons=['alex','wupeiqi','egon','yuanhao','gangdan','oldboy']
linuxs=['egon','oldboy','tiedan','liudan']

l=[]
for item in pythons:
    if item in linuxs:
        l.append(item)
print(l)


作用：去重，关系运算，

定义：
1：每个元素必须是不可变类型(可hash，可作为字典的key)
2:没有重复的元素
3：无序
s={1,2,'a','b','c','d','e','f'} #s=set({1,2,'a'})

print(type(s),s)

集合

 

长度len
s={1,2,'a','b','c','d','e','f'}
print(len(s))

长度

 

#长度len
s={1,2,'a','b','c','d','e','f'}
print(len(s))

成员运算in和not in

 

s={1,2,'a','b','c','d','e','f'}
print('a' in s)

成员运算in和not in

 

s={1,2,'a','b','c','d','e','f'}
for item in s:
    print(item)

取值

 

#| 并集
s1={1,2,3}
s2={3,4,5}
print(s1 | s2)

#& 交集
print(s1 & s2)

#-差集
print(s1 - s2)
print(s2 - s1)

#^ 对称差集
s1={1,2,3}
s2={3,4,5}


==
> ， >= ， <, <= 父集，子集
s1={1,2,3,4}
s2={3,4,5}
print(len(s1) > len(s2))

s1={1,2,3,4}
s2={3,4}
print(s1 > s2)
print(s1 >= s2)


#| 并集
print(s1.union(s2))

#& 交集
print(s1.intersection(s2))
s1.intersection_update(s2) #s1=s1.intersection(s2)
print(s1)
#-差集
print(s1.difference(s2))

#^ 对称差集
print(s1.symmetric_difference(s2))

交、 差 、并、对称差集

 

l=['a','b',1,'a','a']
print(list(set(l)))

l=['a','b',1,'a','a']
l_new=list()
s=set()
for item in l:
    if item not in s:
        s.add(item)
        l_new.append(item)
l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]
l_new=list()
s=set()
for item in l:
    res = (item['name'], item['age'], item['sex'])
    if res not in s:
        s.add(res)
        l_new.append(item)

去重

 

八 数据类型总结

1.按存储空间的占用分（从低到高）

数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

按照存储空间

 

2.按存值个数区分

标量／原子类型	数字，字符串
容器类型	列表，元组，字典

 

3.按可变不可变区分

 

可变	列表，字典
不可变	数字，字符串，元组

 

 4.按访问顺序区分

直接访问	数字
顺序访问（序列类型）	字符串，列表，元组
key值访问（映射类型）	字典