zoukankan      html  css  js  c++  java

  • 二 python之数据类型和字符编码

    一. 数据类型

    数字类型

    • 整形int
    1. 用途：年龄，等级，qq号等
    2. 定义方式
      age=18 #age=int(18)
    3. 只能存一个值, 且为不可变类型
    x=11
print(id(x))
x=12
print(id(x))
    • 浮点型float
    1. 用途：身高，体重，体质参数等
    2. 定义方式
      salary = 3.1 # salary=float(3.1)
    3. 只能存一个值, 且为不可变类型

    字符串

    1. 作用：名字，性别，国籍，地址等描述信息

    2. 定义：在单引号双引号三引号内，由一串字符组成
      name='hello world'

    3. 该类型总结

      1 只能存一个值
      2 有序
      3 不可变：值变，id就变。不可变==可hash

    优先掌握的操作：

    1. 按索引取值(正向取+反向取) ：只能取

      print(msg[0],type(msg[0]))
print(msg[-1])

    2. 切片(顾头不顾尾，步长)

      print(msg[0:3]) #>=0 <3
print(msg[0:7]) #>=0 <7
print(msg[0:7:1]) #>=0 <7
print(msg[0:7:2]) #hello w   #hlow
print(msg[:])
print(msg[5:1:-1])
print(msg[-1::-1])

    3. 长度len

      print(msg.__len__())
print(len(msg)) #msg.__len__()

    4. 成员运算in和not in

      msg='hello world'
print('llo' in msg)
print('llo' not in msg)

    5. 移除空白strip

      password='    alex3714     '
print(password.strip())

password=input('>>: ').strip()

password='alex 3714     '
print(password.strip())

    6. 切分split

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

      cmd='get /root/a/b/c/d.txt'
print(cmd.split())

file_path='C:\a\d.txt'
print(file_path.split('\',1))

file_path='C:\a\d.txt'
print(file_path.rsplit('\',1))

    7. 循环

      for i in range(len(msg)): #0 1 2
    print(msg[i])

    需要掌握的操作

    1. strip,lstrip,rstrip

      print("**alex****".strip('*'))
print("**alex****".lstrip('*'))
print("**alex****".rstrip('*'))

    2. lower,upper

      print('ALeX'.lower())
print('aaa'.upper())

    3. startswith,endswith

      msg="hello world"
print(msg.startswith('hello'))
print(msg.startswith('h'))
print(msg.endswith('world'))

    4. format的三种玩法

      print('my name is %s my age is %s' %('alex',18))

print('my name is {} my age is {}'.format('alex',18))
print('my name is {} my age is {}'.format(18,'alex'))

print('{0} {1} {0}'.format('alex',18))

print('my name is {name} my age is {age}'.format(age=18,name='male'))

    5. split rsplit

      name='root:x:0:0::/root:/bin/bash'
print(name.split(':')) #默认分隔符为空格
name='C:/a/b/c/d.txt' #只想拿到顶级目录
print(name.split('/',1))

name='a|b|c'
print(name.rsplit('|',1)) #从右开始切分

    6. join

      info='root:x:0:0'
l=info.split(':')
print(':'.join(l))

l=[1,2,3]
print(':'.join(l)) #报错：只有在列表内的元素全是字符串类型，才能用join拼接

    7. replace

      name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1)) #1为指定替换第几个, 如果不写就全部替换

    8. isdigit

      age=input('>>: ').strip()
print(age.isdigit()) #age='123'
if age.isdigit():
    age=int(age)
else:
    print('必须输入数字')

    9. 练习

      # 写代码,有如下变量,请按照要求实现每个功能 （共6分，每小题各0.5分）
name = " aleX"
# 1)    移除 name 变量对应的值两边的空格,并输出处理结果
# 2)    判断 name 变量对应的值是否以 "al" 开头,并输出结果

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

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

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

# 8)    请输出 name 变量对应的值的第 2 个字符?
# 9)    请输出 name 变量对应的值的前 3 个字符?
# 10)    请输出 name 变量对应的值的后 2 个字符?

# 11)    请输出 name 变量对应的值中 “e” 所在索引位置?

# 12)    获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。

      # 1. print(name.strip())
# 2. print(name.startswith('al'))
# 3. print(name.endswith('X'))
# 4. print(name.replace('l','p'))
# 5. print(name.split('l'))
# 6. print(name.upper())
# 7. print(name.lower())
# 8. print(name[1])
# 9. print(name[:3])
# 10. print(name[-2:])
# 11. print(name.index('e',1))
# 12. print(name[:-1])

    列表

    1. 作用：多个装备，多个爱好，多门课程

    2. 定义：[]内可以有多个任意类型的值，逗号分隔

    3. 该类型总结

      1 可以存多个值，值都可以是任意类型
      2 有序
      3 可变：值变，id不变。可变==不可hash

      优先掌握的操作：

    4. 按索引存取值(正向存取+反向存取)：即可存也可以取

      l=['zhao','qian','sun','li',5,6]

    5. 切片(顾头不顾尾，步长)

    6. 长度

      print(l.__len__())
print(len(l))

    7. 成员运算in和not in

      print('zhao' in l)

    8. 追加

      l.append(6)
print(l	)

    9. 删除

      #单纯的删除
del l[0]
print(l)

res=my_girl_friends.remove('yuanhao')
print(my_girl_friends)
print(res)
print(my_girl_friends)

#del和remove都没有返回值, 只是删除

      #删除并拿到结果:取走一个值
res=l.pop(2)
res=l.pop() #默认删除并返回列表最后一个值
print(res)

      # my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
# print(my_girl_friends.pop(0)) #'alex'
# print(my_girl_friends.pop(0)) #'wupeqi'
# print(my_girl_friends.pop(0)) #'yuanhao'

    10. 循环

    my_girl_friends=['alex','wupeiqi','yuanhao',4,5]

i=0
while i < len(my_girl_friends):
    print(my_girl_friends[i])
    i+=1

for item in my_girl_friends:
    print(item)

    需要掌握的方法

    1. insert

      l=['zhao','qian','sun','li',5,6]

      l.insert(0,'wang')
print(l)

    2. clear

      l.clear()
print(l)

    3. copy

      l2=l.copy()
print(l2)

    4. count

      l.insert(0,'zhao')
print(l.count('zhao'))

    5. extend

      l1=['zhou','wu']
l.extend(l1)
l.extend('hello')
print(l)
# ['zhao', 'qian', 'sun', 'li', 5, 6, 'zhou', 'wu', 'h', 'e', 'l', 'l', 'o']

    6. index

      print(l.index('wu'))
print(l.index('wuuuu'))

    7. reverse

      l.reverse()
print(l)

    8. sort

      从python2.4开始，list.sort()和sorted()函数增加了key参数来指定一个函数，此函数将在每个元素比较前被调用。 例如通过key指定的函数来忽略字符串的大小写：
      >>> sorted("This is a test string from Andrew".split(), key=str.lower)
      ['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']
      key参数的值为一个函数，此函数只有一个参数且返回一个值用来进行比较。这个技术是快速的因为key指定的函数将准确地对每个元素调用。
      更广泛的使用情况是用复杂对象的某些值来对复杂对象的序列排序，例如：

    >> student_tuples = [ 
          ('john', 'A', 15), 
          ('jane', 'B', 12), 
          ('dave', 'B', 10), 
  ] 
>> sorted(student_tuples, key=lambda student: student[2])   # sort by age 
  [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

    l=[1,10,4,11,2,]
l.sort(reverse=True)
print(l)
    字符串大小比较
    x='healloworld'
y='he2'

print(x > y)

    1. 匿名函数

      ##### 按年龄排序

      l=[
      {'name':'alex','age':84},
      {'name':'oldboy','age':73},
      {'name':'egon','age':18},
      ]
      l.sort(key=lambda item:item['age'],reverse=False)

    元组

    1. 作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读

    2. 定义：与列表类型比，只不过[]换成()

      age=(11,22,33,44,55) #本质age=tuple((11,22,33,44,55))

    3. 该类型总结

      1 可以存多个值，值都可以是任意类型
      2 有序
      3 不可变：值变，id就变。不可变==可hash

    优先掌握的操作

    1. 按索引取值(正向取+反向取)：只能取
    2. 切片(顾头不顾尾，步长)
     print(age[0:3])
 print(age)
    1. 长度
    age=(11,22,33,44,55)
print(len(age))
    1. 成员运算in和not in
    age=(11,22,33,44,55)
print(11 in age)
    1. 循环
    for item in age:
  print(item)

    字典

    1. 用途：存放多个值，key:value,存取速度快

    2. 定义：key必须是不可变类型（int，float，str，tuple），value可以是任意类型

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

    3. 该类型总结

      1 可以存多个值，值都可以是任意类型,key必须是不可变类型
      2 无序
      3 可变：值变，id不变。可变==不可hash

    优先掌握的操作

    1. 按key存取值：可存可取

      d={'name':'ross'}
print(d['name'])

d['age']=18
print(d)

    2. 长度len

    info={'name':'ross','age':18,'sex':'male'}
print(len(info))
    1. 成员运算in和not in
    info={'name':'ross','age':18,'sex':'male'}
print('name' in info)
    1. 删除
    info={'name':'ross','age':18,'sex':'male'}
print(info.pop('name')) #指定删除name, 并返回name对应的值
print(info)
print(info.popitem()) #('sex', 'male') #随机删除, 因为字典是无序的
print(info)
    1. 键keys()，值values()，键值对items() #了解
    info={'name':'ross','age':18,'sex':'male'}

print(info.keys())
print(list(info.keys())[0])

print(list(info.values()))
print(list(info.items()))
    1. 循环
    info={'name':'egon','age':18,'sex':'male'}
for k in info:
    print(k,info[k])
    
for k,v in info.items():
    print(k,v)

    其他需要掌握的方法

    1. get和pop

      info={'name':'egon','age':18,'sex':'male'}
print(info['hobbies'])              #没有hobbies这个key, 会报错
print(info.get('hobbies','没有'))    #使用get方法, 如果没有key, 会返回设定的值
print(info.pop('name1',None))       #pop会删除对应key, 如果没有, 会返回设定的值

    2. update: 字典 update() 函数把字典参数d的 key/value(键/值) 对更新到字典 info 里

      info={'name':'egon','age':18,'sex':'male'}
d={'x':1,'y':2,'name':'EGON'}
info.update(d)
print(info)

    3. setdefault

      1：key存在，则不赋值，key不存在则设置默认值
      2：key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值

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

    4. 小示例

      info={'name':'egon',}
info['hobbies']=[]
info['hobbies'].append('music')
info['hobbies'].append('read')
print(info)

      info={'name':'egon',}
if 'hobbies' not in info:
    info['hobbies']=[]
else:
    info['hobbies'].append('music')

      hobbies_list=info.setdefault('hobbies',[])
print(hobbies_list)
hobbies_list.append('play')
hobbies_list.append('read')

print(info)

    练习

    #1 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中
#即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}
l=[11,22,33,44,55,66,77,88,99,90]
d={'k1':[],'k2':[]}
for i in l:
    if i < 66:
        d['k1'].append(i)
    if i >= 66:
        d['k2'].append(i)
print(d)

    # 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()
d={}
for i in l:
    d.setdefault(i,l.count(i))
print(d)


s='hello alex alex say hello sb sb'
l=s.split()
d={}
for i in l:
    if i in d:
        d[i]+=1
    else:
        d[i]=1
print(d)

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

msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
goods=[]
while True:
    for k in msg_dic:
        print(k,msg_dic[k])
    choice=input('what do you want to buy? : ')
    if choice=='q':break
    if not choice or choice not in msg_dic:continue
    num=input('how many do you want to buy? : ')
    if not num.isdigit():continue
    t=(choice,num,msg_dic[choice])
    goods.append(t)
    print(goods)

    集合

    1. 作用: 关系运算, 去重
    2. 定义: {}内用逗号分割每个元素都必须是不可变类型,元素不能重复,无序

    优先掌握的操作

    1. 长度len

      s={1,2,3,1} #s=set({1,2,3,1})
print(len(s))

    2. 成员运算in, not in

      names={'egon','alex'}
print('egon' in names)

    3. 合集 |

      pythons={'egon','axx','ysb','wxx'}
linuxs={'egon','oldboy','oldgirl','smallboy','smallgirl'}
print(pythons|linuxs)

    4. &交集:同时报名两门课程的学生

      print(pythons & linuxs)
print(pythons.intersection(linuxs))

    5. ^对称差集:没有同时报名两门课程

      print(pythons ^ linuxs)
print(pythons.symmetric_difference(linuxs))

    6. -差集：只报名python课程的学生

      print(pythons - linuxs)
print(pythons.difference(linuxs))

    7. 父集:>,>=,子集：<，<=

      s1={1,2,3}
s2={1,2,}
print(s1 >= s2)
print(s1.issuperset(s2))
print(s2.issubset(s1))

linuxs={'egon','oldboy','oldgirl','smallboy','smallgirl'}
for student in linuxs:
    print(student)
  • 相关阅读:
    第12组(78) Beta冲刺 (2/5)（组长）
    第12组 Beta冲刺 (1/6)（组长）
    软工实践个人总结
    第 02 组 每周小结 (3/3)
    第02组 每周小结（2/3）
    第02组 每周小结 (1/3)
    第02组Beta冲刺 总结
    第02组Beta冲刺（5/5）
    第02组Beta冲刺（4/5）
    第02组Beta冲刺（3/5）
  • 原文地址：https://www.cnblogs.com/peitianwang/p/10562053.html
Copyright © 2011-2022 走看看