python 变量的非数字型和集合

小鱼儿 2022-05-15 10:22 343阅读 0赞

## 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)

![70][]

**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.

![70 1][]

示例2：

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

![70 2][]

**二、列表**（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\]

![70 3][]

**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

![70 4][]

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

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

![70 5][]

3）随机排序

![70 6][]

**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）将字符串里的元素分割，并用变量去接元素（被注释掉的操作与执行的操作效果一致）

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

![70 7][]

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

![70 8][]

![70 9][]

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

先导入math

![70 10][]

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

![70 11][]

8.列表的相关案例

案例

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

![70 12][]

![70 13][]

**三、元组**（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\] 反转

![70 14][]

2）重复  
print allowUsers \* 3

![70 15][]  
3）连接  
print allowUsers + ('fensi','fendai')

![70 16][]  
4） 成员操作符  
print 'westos' in allowUsers  
print 'westos' not in allowUsers

![70 17][]

**3.元组的应用场景**

1）变量交换数值

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

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

![70 19][]

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

![70 20][]

\#排序

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

![70 21][]

## **四、字典（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

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

![70 23][]

**3.字典的管理**

1）字典的增加

\#普通添加

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

\#    .update

![70 24][]

\#  .setdefault

![70 25][]

2）字典的删除

pop:弹出指定的key-value值

![70 26][]

del 从内存在中删除

![70 27][]

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分以上的学生

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

![70 28][]

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

![70 29][]

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

get 返回指定键的值

![70 30][]

5.相关示例

示例一

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

![70 31][]

![70 32][]

## ![70 33][] ##

示例2

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

![70 34][]

## **五、集合(set)** ##

**1.集合的定义**

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

![70 35][]

2）定义一个空集合

s2=(\[ \])

3)集合的应用

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

![70 36][]

**2,集合的特性**

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

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

![70 37][]

**3.集合的常用方法**

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

1)增加  (.add   .update)

![70 38][]

2)删除（pop,remove)

![70 39][]

3)交集、并集

![70 40][]

4)差集

![70 41][]

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

![70 42][]

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)

[70]: /images/20220515/6155046edabd4417a48a3d00a9a53213.png
[70 1]: /images/20220515/c2264e0de13c415b9a48ff51170d06f2.png
[70 2]: /images/20220515/a64d17c0a2044e83a4c28690f6e657a7.png
[70 3]: /images/20220515/67afdcae4d1a45de96fdafbbb8f9a647.png
[70 4]: /images/20220515/1a767592d35b40588c08f4d1b36ead83.png
[70 5]: /images/20220515/b0071dedc01f46e5b1fdb192514514fb.png
[70 6]: /images/20220515/87207508e1ee4b199549f33c67640689.png
[70 7]: /images/20220515/3da18d4d7adc4def8ef86e2be75d233e.png
[70 8]: /images/20220515/f747f1628f6648d8a6efcbe82300e9e4.png
[70 9]: /images/20220515/1d960d1440e844c7a58258e563ac290e.png
[70 10]: /images/20220515/5d4f2db54af243208a48b0fa52be3ece.png
[70 11]: /images/20220515/9a6b8c4ed7894df1a90ca839c991fb19.png
[70 12]: /images/20220515/b1ec01c0f9f04c0d8f4a120b8f07b6e8.png
[70 13]: /images/20220515/25f5857b5cd746f098f08284838dcbca.png
[70 14]: /images/20220515/548495888bdf42eea1a2e81937dc3d16.png
[70 15]: /images/20220515/73f49efe9a804f25bb3dcd29bc596532.png
[70 16]: /images/20220515/4df4369fe9d948e491155ddc36d1a1c3.png
[70 17]: /images/20220515/0a85fc33d6004de58572410ae540f5bf.png
[70 18]: /images/20220515/9545387630f2444cad37797513bfcc6b.png
[70 19]: /images/20220515/9d4f6077f70a4260989e86607264b2d4.png
[70 20]: /images/20220515/b9074d62efa64b6ead2e0b70f327c2f7.png
[70 21]: /images/20220515/0ce7115e0ca84ff49205865a04ac9823.png
[70 22]: /images/20220515/e9999ab05e9d48e698ee10c7e097422f.png
[70 23]: /images/20220515/e2b8aa514d284eb7bfe044b883e888cc.png
[70 24]: /images/20220515/90b4e128a59945e2bc5d0f42c7c6b678.png
[70 25]: /images/20220515/f31359cfc39d42ecbc7c8873dc1266ec.png
[70 26]: /images/20220515/518219d9b4914597a0bc5af794a0e1b5.png
[70 27]: /images/20220515/09441ef5794243b9a3da15111b696d25.png
[70 28]: /images/20220515/1bdd0dda7bff4891886e2687f6bcce29.png
[70 29]: /images/20220515/f3cddab6affd441497acdab7a702b4f2.png
[70 30]: /images/20220515/5546dd75bb4a40cba90c1636c800710c.png
[70 31]: /images/20220515/b817e2c1e62f425ebf18135a42a05d14.png
[70 32]: /images/20220515/d763d1b464124083b149f784d39c8562.png
[70 33]: /images/20220515/5e0ad9bb255d4c5ab35829c8494042a0.png
[70 34]: /images/20220515/797feabcfa2944328c1fedcb206aaa42.png
[70 35]: /images/20220515/6b97c899a5604a38a635512a4b5cee88.png
[70 36]: /images/20220515/3dedc8ccb7bd4bf89c08bf55e6f8b314.png
[70 37]: /images/20220515/255ff993ea4140d0b8886dc0ffcf5c18.png
[70 38]: /images/20220515/12481ee437b244f8895cb2f3cda36787.png
[70 39]: /images/20220515/6a18894ad6344471a1b0caef0c2b01ef.png
[70 40]: /images/20220515/f34bb289880f4da3846954a0e800f16c.png
[70 41]: /images/20220515/6e4c60e51d8b4f9cbca68b01696cfe22.png
[70 42]: /images/20220515/4f3e65f9c388432b983486e4ba01a2fd.png