python 变量的非数字型和集合

python 变量中的非数字型有：str , tuple , dict , list

一、字符串（str）

1.字符串中元素的判定与更改

• 判断字符串里面的每个元素是否为什么类型

# 一旦有一个元素不满足，就返回False
print '123'.isdigit()
print '123abc'.isdigit()

•  title:标题 判断某个字符串是否为标题(第一个首字母大写，其余字母小写)

print 'Hello'.istitle()   
print 'HeLlo'.istitle()

• 转换大小写：

print 'hello'.upper()    转换为大写
print 'HELLO'.lower()  转换为小写

• 判断大小写

print 'hello'.islower()
print 'HELLO'.isupper()

•  isalnum()  判断字符串是否包含字母数字字符

print 'hello'.isalnum()

•   isalpha()  检查字符串是否仅由字母组成

print '123'.isalpha()
print 'qqq'.isalpha()

2.字符串开头和结尾匹配

s = 'hello.jpg'
1) endswith : 找出字符串是否以XXX结尾
print s.endswith('.png')

url1 = 'http://www.baidu.com'
url2 = 'file:///mnt'

2) startswith：找出字符串是否以xxx开头

print url1.startswith('http://')
print url2.startswith('f')

3.split对于字符串进行分离
date = '2018-8-27'
date1 = date.split('-')    #分隔符与字符串本身分隔符一致
print date1

4.join: 连接
print ''.join(date1)
print '/'.join(date1)

5.字符串的定义方式

a = "hello"
b = 'westos'
c = "what's up"
d = """
    用户管理
1.添加用户
2.删除用户
3.显示用户
"""
print a
print b
print c
print d

6.字符串的搜粟和替换

s = 'hello world'
#print len(s)    len() 获取字符串长度

1） find找到字符串 并返回最小的索引
print s.find('hello')

print s.find('world')

2）replace替换：replace前的是要被替换的字符，后面的是替换的字符

print s.replace('hello','westos')

7.字符串的特性

1）索引：0,1,2,3,4 索引值是从0开始
s = 'hello'
print s[0]
print s[1]

2）切片
切片的规则：s[start:end:step] 从start开始到end-1结束,步长:step
如：print s[0:4:2]

显示所有字符     print s[:]
显示前3个字符   print s[:3]
对字符串倒序输出  print s[::-1]
除了第一个字符以外，其他全部显示  print s[1:]

3） 重复
print s * 10   重复10遍s

4） 连接
print 'hello ' + 'world'

5）成员操作符  （什么是否在什么里面）
print 'q' in s       
print 'he' in s
print 'aa' in s

8.  count() :统计字符串中某个字符出现的次数

print 'helloooo'.count('o')    统计字符串中o出现的次数

9.相关案例

示例1：

输入一行字符,统计其中有多少个单词,每两个单词之间以空格隔开。
如输入: This is a c++ program. 输出：There are 5 words in the line.

 示例2：

给出一个字符串，在程序中赋初值为一个句子，例如"he threw three free throws"，
 自编函数完成下面的功能：
    求出字符列表中字符的个数（对于例句，输出为26）

二、列表（list）

数组:存储同一种数据类型的集合 scores=[12,13,14]
列表：(打了激素的数组):可以存储任意数据类型的集合，一个变量可以存储多个信息

1.列表的特点

1）列表里可以存储不同的数据类型

如：li = [1,1.2,True,'hello']     #创建列表
print li               
print type(li)           #查看列表内存储数据的类型

2）列表里面也可以嵌套列表(列表：也是一种数据类型)
li = [1,1.2,True,'hello',[1,2,3,4,5]]
print li
print type(li)

3）创建一个空列表

li = [ ]

2.列表的特性

service = ['http', 'ssh', 'ftp']

1）索引

print service[0]   取第一个元素
print service[-1] 取最后一个元素

2） 切片
print service[::-1] # 列表的反转
 print service[1:] # 除了第一个元素之外的其他元素
 print service[:-1] # 除了最后一个元素之外的其他元素

3）重复
 print service * 3

4）连接
service1 = ['mysql','firewalld']
 print service + service1

5）成员操作符
print 'firewalld' in service
 print 'firewalld' in service1
 print 'firewalld' not in service

6）for循环遍历
 print '显示服务'.center(50,'*')
 for se in service:
     print se

3.列表里嵌套列表
service2 = [['http',80],['ssh',22],['ftp',21]]
# 索引
print service2[0][1]     #service里第一个元素里面的第二个元素
print service2[-1][1]    #service里最后一个元素里面的第二个元素
# 切片
print service2[:][1] 
print service2[:-1][0]
print service2[0][:-1]

4.列表的查看

service = ['http', 'ssh', 'ftp','ftp']

1）查看列表中元素出现的次数

print service.count('ssh')

2）查看指定元素的索引值

print service.index('ssh')

5.列表的排序

kong = ['a','A','c','D']

1）按照Ascii码进行排序的
kong.sort()
 print kong

#倒序

kong.sort(reverse=True)

print kong

2）对字符串排序不区分大小写

下面两条代码的执行结果一样，选任一个即可
# #noah.sort(key=str.lower)
# noah.sort(key=str.upper)

3）随机排序

6.列表的管理

1）列表的增加

service = ['http', 'ssh', 'ftp']

• print service + ['firewalld']
• append:追加 追加一个元素到列表中

    service.append('firewalld')
     print service

• extend:拉伸 追加多个元素到列表中

    service.extend(['mysql', 'firewalld'])
    print service

•  insert:在指定索引位置插入元素

     service.insert(1,'samab')
      print service

2）列表删除

service = ['http', 'ssh', 'ftp']

• 如果pop()不传递值的时候，默认弹出最后一个元素

     print service.pop()

• pop()也可以传递索引值

     print service.pop(0)

• remove:删除指定的元素

  service.remove('ssh')
  print service

• del 关键字 从内存中删除列表

  print service
 del service
 print  service

3）列表的修改

service = ['http', 'ssh', 'ftp']

• 通过索引，重新赋值

service[0] = 'mysql'
print service

•  通过切片

print service[:2]
service[:2] = ['samba','ladp']
print service

7.列表的生成式

1）将字符串里的元素分割，并用变量去接元素（被注释掉的操作与执行的操作效果一致）

正在执行的代码类型：被称为生成式

2）生成一个列表，列表元素分别为[1**2,2**2,3**2,4**2...8**2]

3）找出1~10之间的所有偶数，并且返回一个列表(包含以这个偶数为半径的圆的面积)

先导入math

4)找出1～10之间的所有奇数，并且返回一个列表(所有的奇数转换为字符串)

8.列表的相关案例

案例

1.系统里面有用户 用户有密码
    users = ['root','westos']
    passwds = ['123','456']
2.用户登陆(判断用户登陆是否成功)
    1).判断用户是否存在
        2).如果存在：
            判断用户密码是否正确：先找出用户对应的索引，
            根据passwds[索引值]
            如果正确：登陆成功，退出循环
            如果密码不正确：重新登陆 (机会只有三次)
    2).不存在
    重新登陆(机会只有三次)

三、元组（tuple）

1.元组的创建

元组(tuple)：带了紧箍咒的列表
元组本身不可变数据类型，没有增删改差
元组内可以存储任意数据类型

基本结构：t = (1,2,3,4.0,'star')

元组里面包含可变数据类型，可以间接修改元组的内容
t1 = ([1,2,3],4)
t1[0].append(4)
print t1

元组如果只有一个元素的时候，后面一定要加逗号，否则数据类型不确定
t2 = ('hello',)
t3 = (1,)

2.元组的特性

allowUsers = ('root','westos','fentiao')
allowPasswd = ('123','456','789')

1）索引 、 切片
print allowUsers[0]    第一个元素
print allowUsers[-1]   最后一个元素
print allowUsers[1:]   除了第一个元素
print allowUsers[2:]   除了前两个元素
print allowUsers[:-1] 除了最后一个元素
print allowUsers[::-1] 反转

2）重复
print allowUsers * 3

3）连接
print allowUsers + ('fensi','fendai')

4） 成员操作符
print 'westos' in allowUsers
print 'westos' not in allowUsers

3.元组的应用场景

1）变量交换数值

相当于将a,b封装为一个元组（1，2），当在执行b,a=a,b时，实则是用了一次索引取值 b=(1,2)[ 0] a=(1,2)[1]

2)打印变量值
# name = 'westos'
# age = 10
# t = (name,age)   #变量值
# print 'name: %s,age: %d' %(name,age)   #这两条代码的执行效果一致
# print 'name: %s,age: %d' %t

3）元组的赋值：有多少个元素，就用多少个变量接收
# t = ('li',10,100)
# name,age,score = t
# print name,age,score

#排序

scores = (100,89,45,78,65)
scores = sorted(scores)
print scores

四、字典（dict)

1.定义

字典是一个无序的数据集合，使用print输出字典的时候
通常输出的顺序和定义的顺序是不一致的

创建一个空字典  d=dict()

创建一对值  d = dict(a=1,b=2)

2.特性

d = dict(a=1,b=2)

1）成员操作符(默认判断key值是否存在)
print 'a' in d
print 1 in d

2）for循环(默认循环遍历字典的key值)
for i in d:
 print i

3.字典的管理

1）字典的增加

#普通添加

d = dict(a=1, b=2)
# print d
# # 添加或者更改key-value对
# d['g'] = 10
# print d
# d['a'] = 10
# print d

#    .update

#  .setdefault

2）字典的删除

pop:弹出指定的key-value值

del 从内存在中删除

3）字典的修改与查看

# 查看字典里面所有的key值
print service.keys()

# 查看字典里面所有的value值
print service.values()

# 查看字典里面所有的key-value值
print service.items()

# 遍历
for k,v in service.items():
    print k,'---->',v

for k in service:
    print k,'----->',service[k]

get方法获取指定key对应的value值
    如果key值存在，返回对应的value值
    如果key值不存在，默认返回None,如果需要指定返回值，传值即
print service.get('http','key not exist')

4.字典的生成式

1)假设有20个学生，学分在60～100之间，筛选出成绩在90分以上的学生

注释掉的是一般的操作方式，正在运行的是生成式

2)将字典中的key值和value值调换

3)大小写合并，key值最终全部为小写

get 返回指定键的值

5.相关示例

示例一

重复的单词: 此处认为单词之间以空格为分隔符， 并且不包含，和.；
    # 1. 用户输入一句英文句子；
    # 2. 打印出每个单词及其重复的次数;
 "hello java hello python"
# hello 2
# java 1
# python 1

示例2

数字重复统计:
    1). 随机生成1000个整数;
    2). 数字的范围[20, 100],
    3). 升序输出所有不同的数字及其每个数字重复的次数;

 

五、集合(set)

1.集合的定义

1）集合里面的元素是不可重复的
s = {1,2,3,1,2,3,4,5}

2）定义一个空集合

s2=([ ])

3)集合的应用

用集合的方法给列表元素去重

2,集合的特性

集合只支持 成员操作符 for循环

枚举：返回索引值和对应的value值

3.集合的常用方法

s = {6, 7, 8, 1, 2, 3}

1)增加  (.add   .update)

2)删除（pop,remove)

3)交集、并集

4)差集

5)对等差分:并集-交集

6)子集，超集

s3 = {1, 2}
s4 = {1, 2, 3}

s3是否为s4的子集    ： print s3.issubset(s4)

s3是否为s4的超集
# 什么是超集：如果s3中的每一个元素都在集合s4中，且
# s4中可能包含s3中没有的元素，则s3就是s4的一个超集
print s3.issuperset(s4)

7）两个集合是不是不相交
print s3.isdisjoint(s4)