python3基础笔记，二python的基本数据类型与运算符

1.算术运算符

假设变量a的值是10，变量b的值是21，则 -

2.比较(关系)运算符

比较(关系)运算符比较它们两边的值，并确定它们之间的关系。它们也称为关系运算符。假设变量a的值10，变量b的值是20，则 -

3.赋值运算符

假设变量a的值10，变量b的值是20，则 -

4.逻辑运算符

Python语言支持以下逻辑运算符。假设变量a的值为True，变量b的值为False，那么 -

5.按位运算符

按位运算符执行逐位运算。 假设变量a = 60; 和变量b = 13; 现在以二进制格式，它们将如下 -

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a = 1100 0011

Shell

Python的内置函数bin()可用于获取整数的二进制表示形式。

以下是Python语言支持位运算操作符 -

6.成员运算符

Python成员运算符测试给定值是否为序列中的成员，例如字符串，列表或元组。 有两个成员运算符，如下所述 -

7.身份运算符

身份运算符比较两个对象的内存位置。常用的有两个身份运算符，如下所述 -

8. 运算符优先级

下表列出了从最高优先级到最低优先级的所有运算符，如下所示 -

二、数据类型：

1、数字

　　int（整型）

　　float（浮点型）

    def bit_length(self): 
        """ 返回表示该数字的时占用的最少位数 """
        """
        int.bit_length() -> int
        
        Number of bits necessary to represent self in binary.
        >>> bin(37)
        '0b100101'
        >>> (37).bit_length()
        6
        """
        return 0

 def __int__(self): 
        """ 转换为整数 """ 
        """ x.__int__() <==> int(x) """
        pass
#等价于 int(x)

2、字符串：str

字符串一旦创建之后就不能修改，若修改就会重新创建一个新的字符串。

字符串可以用 len() 函数来返回字符串内含有多少字符

（1）字符串常用方法：

　　1、upper(self)　　---->将字符串中所有字母大写，不去管其它非字母字符。

　　　　参数：无

　　　　返回值：字符串

str1 = 'hello my name is 张'
print(str1.upper())

　　输出：

HELLO MY NAME IS 张

　　2、lower(self)　　---->把全部字母字符转换成小写，不去管其它非字母字符。

　　　　参数：无

　　　　返回值：字符串

str1 = 'Zbuter'
print(str1.lower())

　　输出：

zbuter

　　3、swapcase(self)　　---->将字符串中的大小写字符互换

　　　　参数：无

　　　　返回值：字符串

str1 = '张Zbuter'
print(str1.swapcase())

　　输出：

张zBUTER

　　4、count(self, sub, start=None, end=None)　　---->计算字符串中从 start 开始到 end 结束 sub 出现的次数 start 默认是字符串开始 end 默认是字符串结束

　　　　参数：

　　　　　　sub：字符或字符串

　　　　　　start：开始的索引位置

　　　　　　 end：结束的索引位置

　　　　返回值：字符串中sub出现的次数

hello = 'hello world'
print(hello.count('o'))
print(hello.count('o',6))

　　输出：

2
1

　　5、capitalize(self)　　---->将字符串的首字母大写

　　　　参数：无

　　　　返回值：将字符串的首字母大写的字符串

name = 'zjs'
print(name.capitalize())

　　输出：

Zjs

　　6、casefold(self) 与 lower(self)　　---->将字符串小写　

　　　　参数：无

　　　　返回值：将字符串小写的字符串

name = 'ZJS'
print(name.lower())
print(name.casefold())

　　输出：

zjs
zjs

　　casefold(self) 与 lower(self)的区别是：

　　lower() 只对 ASCII 也就是 'A-Z'有效，但是其它一些语言里面存在小写的情况就没办法了。文档里面举得例子是德语中'ß'的小写是'ss'（这个我也不懂）

　　7、center(self, width, fillchar=None)　　---->将字符串居中用fillchar填充 一共width个字符 默认是使用空格填充　　返回新的字符串

　　　　参数：

　　　　　　width：新形成的字符串长度，如果源字符串比width指定的长度长则直接返回源字符串

　　　　　　fillchar：指定一个字符来填充

　　　　返回值：填充后的字符串

name = 'ZJS'
print(name.center(20))
print(name.center(20, '-'))

　　输出：

        ZJS         
--------ZJS---------

　　8、ljust(self, width, fillchar=None)　　---->返回一个长度为width，左对齐的字符串，最右边填充fillchar，默认为空格。width要大于len(str)，否则返回原字符串。

str1 = 'Zbuter'
print(str1.ljust(20))
print(str1.ljust(20, '-'))

　　输出：

Zbuter              
Zbuter--------------

　　9、rjust(self, width, fillchar=None)　　---->与ljust类似　　右对齐

　　10、lstrip(self, chars=None)　　---->返回一个去除前导字符的新字符串，chars参数是一个字符串，它包含了所有将要被移除的字符集合。默认为空格。

　　　　参数：　　

　　　　　　chars：字符集合

　　　　返回值：字符串

str1 = '       www.zbuter.cn'
str2 = 'www.zbuter.cn'
print(str1.lstrip())
print(str2.lstrip('cnw.'))

　　输出：

www.zbuter.cn
zbuter.cn

　　11、rstrip(self, chars=None)　　---->与lsplit类似　　从右侧开始

　　12、strip(self, chars=None)　　　　---->与lstrip和rstrip类似　　在字符串两头开始匹配。多用于清除字符串两端的空格

　　13、endswith(self, suffix, start=None, end=None)　　---->判断字符串是否以 suffix 结尾 start 默认是字符串开始 end 默认是字符串结束

　　　　参数：

　　　　　　suffix：后缀

　　　　　　start：开始的索引位置

　　　　　　end：结束的索引位置

　　　　返回值：布尔值

hello = 'hello world'
print(hello.endswith('ld'))
print(hello.endswith('asd'))

　　输出：

True
False

　　14、startswith(self, prefix, start=None, end=None)　　---->与endswith类似　　判断是否以prefix开头

　　15、expandtabs(self, tabsize=8)　　---->把字符串中的 tab 符号('\t')转为空格，tab 符号默认的空格数是 8。从头开始数，数到第一个\t正好为8个空格，不足则补空格，如果还有\t，接着从第一个\t数到第二个\t仍然为8个空格，以此类推直到最后一个\t结束。

　　　　参数：

　　　　　　tabsize：指定转换字符串中的 tab 符号('\t')转为空格的字符数，默认的字符数是8。

　　　　返回值：该方法返回字符串中的 tab 符号('\t')转为空格后生成的新字符串。

hello = 'hello\tworld'
print(hello.expandtabs(4))
print(hello.expandtabs(10))

　　输出：

hello   world
hello     world

　　16、find(self, sub, start=None, end=None)　　---->在字符串中查找 sub 出现的位置

　　　　参数：

　　　　　　sub：指定查找的字符串或字符

　　　　　　start：开始的索引位置

　　　　　　end：结束的索引位置

　　　　返回值：sub出现的第一次的索引 如果不存在则返回-1

hello = 'hello\tworld'
print(hello.find('o'))
print(hello.find('z'))

　　输出：

4
-1

　　17、rfind(self, sub, start=None, end=None)　　---->与find类似　　从右侧查找

　　18、index(self, sub, start=None, end=None)　　---->在字符串中查找 sub 出现的位置

　　　　参数：

　　　　　　sub：指定查找的字符串或字符

　　　　　　start：开始的索引位置

　　　　　　end：结束的索引位置

　　　　返回值：sub出现的第一次的索引 如果不存在则抛出异常

hello = 'hello\tworld'
print(hello.index('o'))
print(hello.index('z'))

　　输出：

4
Traceback (most recent call last):
  File "E:/zjs/Python/pythonTest/day01/day01/d1.py", line 36, in <module>
    print(hello.index('z'))
ValueError: substring not found

　　19、rindex(self, sub, start=None, end=None)　　---->与index类似　　从右侧查找

　　20、title(self)　　---->将字符串中所有单词的首字母大写

　　　　参数：无

　　　　返回值：字符串

str1 = 'hello my name is 张'
print(str1.title())

　　输出：

Hello My Name Is 张

　　21、replace(self, old, new, count=None)　　---->用 new 替换原字符串中的 old ，count指定替换的次数

　　　　参数：　　

　　　　　　old：需要替换的字符（串）

　　　　　　new：替换的字符（串）

　　　　　　count：替换的次数不超过count次

　　　　返回值：字符串

str1 = 'www.zbuter.cn'
str2 = 'www.zbuter.cn'
print(str1.replace('.', '。'))
print(str2.replace('.', '，', 1))

　　输出：

www。zbuter。cn
www，zbuter.cn

　　22、partition(self, sep)　　---->该方法用于拆分字符串，返回一个包含三个元素的元组。如果未能在原字符串中找到Sep，则元组的三个元素为：原字符串，空串，空串；否则，从原字符串中遇到的第一个Sep字符开始拆分，元组的三个元素为：Sep之前的字符串，Sep字符，Sep之后的字符串；

　　　　参数：　　

　　　　　　sep：分割标记

　　　　返回值：元祖

str1 = '       www.zbuter.cn'
str2 = 'www.zbuter.cn'
print(str1.partition('.'))
print(str2.partition('z'))

　　输出：

('       www', '.', 'zbuter.cn')
('www.', 'z', 'buter.cn')

　　23、rpartition(self, sep)　　---->与partition类似　　从右侧查找sep

　　24、split(self, sep=None, maxsplit=-1)　　---->返回一个以Sep分隔的列表，maxsplit指定拆分次数（因此，列表中元素的个数为maxsplit + 1）。Sep默认为空格，maxsplit默认不限制拆分次数。

　　　　参数：　　

　　　　　　sep：分隔符

　　　　　　maxsplit：拆分次数

　　　　返回值：字符串

str1 = 'www.zbuter.cn'
str2 = 'www.zbuter.cn'
print(str1.split('.'))
print(str2.split('.', 1))

　　输出：

['www', 'zbuter', 'cn']
['www', 'zbuter.cn']

　　25、rsplit(self, sep=None, maxsplit=-1)　　---->与 split 类似　　从右侧拆分

　　26、splitlines(self, keepends=None)　　---->拆分一个包含多行的字符串，以每行为一个元素返回一个列表 keepends是一个True字符或非零整数

　　　　参数：　　

　　　　　　keepends：是否在列表内也添加换行符

　　　　返回值：字符串

str1 = '123\n456'
str2 = '123\n456'
print(str1.splitlines())
print(str2.splitlines(True))

　　输出：

['123', '456']
['123\n', '456']

　　27、join(self, iterable)　　---->使用连接符str来连接iterable对象中的元素，如果传入一个非iterable对象，如整数、布尔值等，将抛出异常Type Error。

　　　　参数：iterable：使用字符串来连接iterable

　　　　返回值：字符串

str1 = 'Zbuter'
print(str1.join('12'))
print(str1.join('123'))

print(str1.join(123))

　　输出：

1Zbuter2
1Zbuter2Zbuter3
Traceback (most recent call last):
  File "E:/zjs/Python/pythonTest/day01/day01/d1.py", line 39, in <module>
    print(str1.join(123))
TypeError: can only join an iterable

　　28、zfill(self, width)　　---->返回一个长度为width的数字字符串，最左边填充0。如果width小于等于原字符串长度，则返回原字符串。主要用于数字类字符串的格式化。

　　　　参数：

　　　　　　width：填充的宽度

　　　　返回值：字符串

str1 = 'aaa'    
str2 = '123'
print(str1.zfill(5))
print(str2.zfill(5))

　　输出：

00aaa
00123

　　29、format(self, *args, **kwargs)　　---->格式化字符串

　　　　参数：

　　　　　　*args：是用来发送一个（非键值对）可变数量的参数列表给一个函数

　　　　　　**kwargs 允许你将不定长度的键值对, 作为参数传递给一个函数。 如果你想要在一个函数里处理带名字的参数, 你应该使用**kwargs。

　　　　返回值：格式化后的新字符串

str1 = 'my name is {name} age is {age}'
str2 = 'my name is {0} age is {1}'
print(str1.format(name = 'zjs', age = 12))
print(str2.format('zjs', 12))

　　输出：

my name is zjs age is 12
my name is zjs age is 12

更多参考：http://www.cnblogs.com/wupeiqi/articles/5484747.html

　　30、format_map(self, mapping)　　---->　　待更新

　　31、isalnum(self)　　---->字符串中是否只含数字、字母

　　　　参数：无

　　　　返回值：布尔值

str1 = '123abc'
str2 = '123_abc'
print(str1.isalnum())
print(str2.isalnum())

　　输出：

True
False

　　32、isalpha(self)　　---->字符串是否只含有字母

　　　　参数：无

　　　　返回值：布尔值

str1 = 'abcdef'
str2 = '_abc'
print(str1.isalpha())
print(str2.isalpha())

　　输出：

True
False

　　33、isdecimal(self)　　---->字符串是否只包含十进制字符。这种方法只存在于unicode对象。

　　　　参数：无

　　　　返回值：布尔值

str1 = '123'
str2 = 'this123'
print(str1.isdecimal())
print(str2.isdecimal())

　　输出：

True
False

　　34、isdigit(self)　　---->检测字符串是否只由数字组成。

　　　　参数：无

　　　　返回值：布尔值

str1 = '123'
str2 = 'this123'
print(str1.isdigit())
print(str2.isdigit())

　　输出：

True
False

　　35、isidentifier(self)　　---->判断字符串是否是合法的标识符

　　　　参数：无

　　　　返回值：布尔值

str1 = '_a'
str2 = '1a'
print(str1.isidentifier())
print(str2.isidentifier())

　　输出：

True
False

　　36、islower(self)　　---->判断字符串是否全是小写

　　　　参数：无

　　　　返回值：布尔值

str1 = 'abcdefg'
str2 = 'Abcdefg'
print(str1.islower())
print(str2.islower())

　　输出：

True
False

　　37、isnumeric(self)　　---->判断字符串是否只包含数字字符。数字字符范围很大，一般来说，数字字符是拥有如下属性值的字符：Numeric_Type=Digit, Numeric_Type=Decimal或Numeric_Type=Numeric。比较isdecimal()、isdigit()、isnumeric()，几个方法检测的范围依次扩大。

　　　　参数：无

　　　　返回值：布尔值

str1 = '123'
str2 = 'a123'
print(str1.isnumeric())
print(str2.isnumeric())

　　输出：

True
False

　　38、isprintable(self)　　---->判断字符串所包含的字符是否全部可打印

　　　　参数：无

　　　　返回值：布尔值

str1 = 'hello world'
str2 = 'hello\tworld'
print(str1.isprintable())
print(str2.isprintable())

　　输出：

True
False

　　39、isspace(self)　　---->判断字符串是否仅包含空格或制表符

　　　　参数：无

　　　　返回值：布尔值

str1 = '   \t \n'
str2 = ''
print(str1.isspace())
print(str2.isspace())

　　输出：

True
False

　　40、istitle(self)　　---->判断字符串每个单词的首字母是否大写

　　　　参数：无

　　　　返回值：布尔值

str1 = '张家顺'
str2 = 'Zbuter'
str3 = '张家顺Zbuter'
print(str1.istitle())
print(str2.istitle())
print(str3.istitle())

　　输出：

False
True
True

　　41、isupper(self)　　---->与islower()相反 判断字符串是否全部大写

　　42、encode(self, encoding='utf-8', errors='strict')　　---->

　　43、decode(self, *args, **kwargs)　　---->

　　44、maketrans(self, *args, **kwargs)　　

　　45、translate(self, table)　　

　　 maketrans 与 translate 配合使用

str = '30416657'
trans = str.maketrans('0123456789', '零一二三四五六七八九')
print(str.translate(trans))

　　输出：

三零四一六六五七

（2）字符串的索引：

str = 'zbuter'
print(str[0], str[1])
print(str[-1], str[-2])  # 负号代表在字符串后面数

　　输出：

z b
r e

str[0]代表字符串的第一个字符 以此类推

用于获取字符串中某一个字符

（3）字符串的切片：

str = 'zbuter'
print(str[0:2])
print(str[:2])  # 与 str[0:2] 含义相同
print(str[:-1])  # 表示从 0 到 最后一个字符（不含）
print(str[2:-1])    #从第二个字符到最后一个字符）（不含）

　　输出：

zb
zb
zbute
ute

（4）字符串的长度

str = 'zbuter'
print(len(str))

　　输出：

6

（5）字符串内字符的遍历

str1 = "hello my name is zjs"

for s in str1:
    print(s)

　　输出：

h
e
l
l
o
 
m
y
 
n
a
m
e
 
i
s
 
z
j
s

3、列表：list

创建列表：

name_list = ['zhang', 'wang', 'li']
或
name_list ＝ list(['zhang', 'wang', 'li'])

列表内的元素是有序的

（1）常用方法：

　　1.append(self, p_object)　　---->在列表最后追加一个元素

　　　　参数：p_object　　追加的元素

　　　　返回值：None

ls = [1, '2', 'abc']
s = ls.append(5)
print(ls)
print(s)

　　输出：

[1, '2', 'abc', 5]
None

　　列表可以追加任意的数据类型。包括列表、元祖和字典。

　　2.clear(self)　　---->清空字典

　　　　参数：无

　　　　返回值：None

ls = [1, '2', 'abc']
s = ls.clear()
print(ls)
print(s)

　　输出：

[]
None

　　3.copy(self)　　---->字典的浅拷贝　　只拷贝直接子对象

　　　　参数：无

　　　　返回值：列表

ls = [1, '2', 'abc']
s = ls.copy()
print(ls)
print(s)
ls = []
print(ls)
print(s)

　　输出：

[1, '2', 'abc']
[1, '2', 'abc']
[]
[1, '2', 'abc']

　　4.count(self, value)　　---->计算value在列表中出现的次数

　　　　参数：value　　可以是任意类型

　　　　返回值：int类型的数字

ls = [1, '2', 'abc', 1, 1, 1]
s = ls.count(1)
print(ls)
print(s)

　　输出：

[1, '2', 'abc', 1, 1, 1]
4

　　5.insert(self, index, p_object)　　---->在 index 处插入p_object

　　参数：

　　　　　　index：　　索引位置

　　　　　　p_object：需要插入的元素

　　返回值：int类型的数字

ls = [1, '2', 'abc']
s = ls.insert(1, 4)
print(ls)
print(s)
ls.insert(4, 4)            #插入如果超出了列表的索引范围则在最后一个位置插入
print(ls)

　　输出：

[1, 4, '2', 'abc']
None
[1, 4, '2', 'abc', 4]

　　6.index(self, value, start=None, stop=None)　　---->查找value从start开始到stop处出现的索引位置 如果不存在这个值会抛出异常

　　参数：

　　　　　　value：　　需要查找的元素

　　　　　　start：　　开始查找的索引位置 默认是列表的第一个元素

　　　　　　stop：　　结束查找的索引位置 默认是列表的最后一个元素

　　返回值：int类型数字 value第一次出现的索引位置

ls = [0, '2', 'abc', 1, 1, 1]
s = ls.index(1, 2, 4)
print(s)
s = ls.index(1, 2, 3)
print(s)

　　输出：

3
Traceback (most recent call last):
  File "E:/zjs/Python/pythonTest/day01/day01/d1.py", line 69, in <module>
    s = ls.index(1, 2, 3)
ValueError: 1 is not in list

　　7.extend(self, iterable)　　---->在列表后追加一个可迭代的值

　　参数：iterable　　追加的可迭代元素

　　返回值：None

ls = [0, '2', 'abc', 1, 1, 1]
ex = ['a', 'bc', 1, 3]
s = ls.extend(ex)
print(ls)
print(s)

　　输出：

[0, '2', 'abc', 1, 1, 1, 'a', 'bc', 1, 3]
None

　　与append不同，

　　append一个列表是把列表整体追加到列表尾部，

　　extend则是一个一个追加到列表的末尾，

　　extend不接受数字类型，只能传递一个可迭代对象

　　8.pop(self, index=None)　　---->删除列表中最后一个元素。若index指定则删除index处的元素

　　　　参数：index　　删除的元素索引

　　　　返回值：None

ls = [0, '2', 'abc', 1, 1, 1]
ex = ['a', 'bc', 1, 3]
s = ls.pop()
print(ls)
print(s)
s = ls.pop(2)
print(ls)
print(s)

　　输出：

[0, '2', 'abc', 1, 1]
1
[0, '2', 1, 1]
abc

　　9.remove(self, value)　　---->从列表中删除第一个value匹配值

　　　　参数：value　　需要删除的元素

　　　　返回值：None

ls = [0, '2', 'abc', 1, 1, 1]
s = ls.remove(1)
print(ls)
print(s)

　　输出：

[0, '2', 'abc', 1, 1]
None

　　10.reverse(self)　　---->将列表逆置

　　　　参数：None

　　　　返回值：None

ls = [0, '2', 'abc', 1, 1, 1]
s = ls.reverse()
print(ls)
print(s)

　　输出：

[1, 1, 1, 'abc', '2', 0]
None

　11.sort(self, key=None, reverse=False)　　---->对列表进行排序　　若reverse指定为True则为从大到小排序

　　　　参数：　

　　　　　　key：待更新

　　　　　　reverse：排序方式 默认为升序排列

　　　　返回值：None

ls = [4, 1, 3, 6, 7, 2]
s = ls.sort()
print(ls)
print(s)
s = ls.sort(reverse=True)
print(ls)
print(s)

　　输出：

[1, 2, 3, 4, 6, 7]
None
[7, 6, 4, 3, 2, 1]
None

（2）访问列表中的值：

　　使用索引的方式访问列表：

ls = ['baidu', 'souhu', 1995, 2018];
print("ls[0]: ", ls[0])
print("ls[1:5]: ", ls[1:5])

　　输出：

ls[0]:  baidu
ls[1:5]:  ['souhu', 1995, 2018]

　　获得列表中第一个值和最后一个值。

ls = ['baidu', 'souhu', 1995, 2018];

name, *_, year = ls     # *（星）代表name和year中间的所有元素的之赋值给 _（下划线）。

print(name)
print(_)
print(year)

　　输出：

baidu
['souhu', 1995]
2018

（3）列表的更新：

ls = ['baidu', 'souhu', 1995, 2018];
print("ls[3]: ", ls[3])
ls[3] = 1111
print("更新后的ls[3]: ", ls[3])

　　输出：

ls = ['baidu', 'souhu', 1995, 2018];
print("ls[3]: ", ls[3])
ls[3] = 1111
print("更新后的ls[3]: ", ls[3])

（4）列表元素的删除：

ls = ['baidu', 'souhu', 1995, 2018, 'test', 'hello', [1,2,3]]
del ls[2]
print(ls)
ls.remove(2018)
print(ls)
ls.pop()
print(ls)
ls.clear()  #无论列表中有多少元素都全部删除
print(ls)

　　输出：

['baidu', 'souhu', 2018, 'test', 'hello', [1, 2, 3]]
['baidu', 'souhu', 'test', 'hello', [1, 2, 3]]
['baidu', 'souhu', 'test', 'hello']
[]

（5）列表的操作符：

　　列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

　　如下所示：

（5）列表的遍历：

list1 = ['abc', 123, (1, 2), [22, 33, 44, "ttt"]]

for item in list1:
    print(item)

　　输出：

abc
123
(1, 2)
[22, 33, 44, 'ttt']

4、元祖：tuple

元祖的创建方法：

ages = (11, 22, 33, 44, 55)
或
ages = tuple((11, 22, 33, 44, 55))

元祖的元素是有序的。

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

（1）元祖常用方法：

　　1.count(self, value)　　---->与列表中count函数相同

　　2.index(self, value, start=None, stop=None)　　---->与列表中index函数相同

（2）元祖的访问：

tuple1 = ('baidu', 'souhu', 1995, 2018, 'test', 'hello', [1,2,3])

print(tuple1[1])
print(tuple1[2:4])

　　输出：

souhu
(1995, 2018)

　获得元祖中第一个值和最后一个值。

ls =('baidu', 'souhu', 1995, 2018)

name, *_, year = ls     # *（星）代表name和year中间的所有元素的之赋值给 _（下划线）。

print(name)
print(_)                # 如果是元祖取出来的会是列表
print(year)

　　输出：

baidu
['souhu', 1995]
2018

（3）元祖的修改和删除：

　　元祖的直接子元素不能被修改和删除，但间接子元素可以被修改或删除

　　元祖只能被整体删除。

tuple1 = ('baidu', 'souhu', 1995, 2018, 'test', 'hello', [1,2,3])
tuple1[6][1] = 666
print(tuple1)

　　输出：

('baidu', 'souhu', 1995, 2018, 'test', 'hello', [1, 666, 3])

（4）元祖的运算符：

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

（5）元祖的遍历：

tuple1 = ('abc', 123, (1, 2), [22, 33, 44, "ttt"])

for item in tuple1:
    print(item)

　　输出：

abc
123
(1, 2)
[22, 33, 44, 'ttt']

5、字典：dict

字典的创建：

person = {"name": "zjs", 'age': 12}
或
person = dict({"name": "zjs", 'age': 12})

字典中的元素是无序的

（1）字典的常用方法：

1.clear(self)　　---->清空字典内所有键值对与列表相同

　　　　参数：无

　　　　返回值：无

>>> aDict = {'name': 'zjs', 'age':12, 'sex':'male'}
>>> aDict.clear()
>>> print(aDict)
{}

2.copy(self)　　---->对字典的浅拷贝与列表相同

　　　　参数：无

　　　　返回值：字典

>>> aDict = {'name': 'zjs', 'age':12, 'sex':'male'}
>>> bDict = aDict.copy()
>>> print(aDict,bDict)
{'sex': 'male', 'age': 12, 'name': 'zjs'} {'sex': 'male', 'age': 12, 'name': 'zjs'}

3.keys(self)　　---->以列表方式返回字典的所有键

　　　　参数：无

　　　　返回值：dict_keys

>>> aDict = {'name': 'zjs', 'age':12, 'sex':'male'}
>>> print(aDict.keys())
dict_keys(['sex', 'age', 'name'])

4.values(self)　　---->与keys类似，返回字典的所有值

　　　　参数：无

　　　　返回值：dict_values

>>> aDict = {'name': 'zjs', 'age':12, 'sex':'male'}
>>> print(aDict.values())
dict_values(['male', 12, 'zjs'])

5.items(self)　　---->以列表的方式返回字典的键值对 每个键值对用元祖表示

　　　　参数：无

　　　　返回值：dict_items

>>> aDict = {'name': 'zjs', 'age':12, 'sex':'male'}
>>> print(aDict.items())
dict_items([('sex', 'male'), ('age', 12), ('name', 'zjs')])

6.get(self, k, d=None)　　---->获得字典指定键的值

　　　　参数：

　　　　　　k：指定的键

　　　　　　d：如果指定键的值不存在时，返回该默认值值。

　　　　返回值：无

aDict = {'name': 'zjs', 'age': 12, 'sex': 'male'}
name = aDict.get('name')
grade = aDict.get('grade', 3)
print(name,grade)

　　输出：

zjs 3

7.update(self, E=None, **F)　　---->添加指定字典到该字典内如果字典内有该键则更新这个值

　　　　参数：

　　　　　　E：传入字典

　　　　　　**F：传入若干关键字

　　　　返回值：无

aDict = {'name': 'zjs', 'age': 12, 'sex': 'male'}
aDict.update({'grade': 3})    #传入字典
print(aDict)
aDict.update(age = 5, six=6)    #传入关键字
print(aDict)

　　输出：

{'sex': 'male', 'age': 12, 'name': 'zjs', 'grade': 3}
{'six': 6, 'sex': 'male', 'age': 5, 'name': 'zjs', 'grade': 3}

8.pop(self, k, d=None)　　---->删除字典中指定的 键值对 k和与其对应的value并返回这个键 若k不存在则返回指定的d

　　　　参数：

　　　　　　k：删除指定的k

　　　　　　d：若k不存在时候返回默认的d

　　　　返回值：数字/字符串/字典/列表/元祖/.../

aDict = {'name': 'zjs', 'age': 12, 'sex': 'male'}
a = aDict.pop('name')
print(a, aDict)
b = aDict.pop('grade',3)
print(b, aDict)

　　输出：

zjs {'sex': 'male', 'age': 12}
3 {'sex': 'male', 'age': 12}

9.popitem(self)　　---->随机删除字典中的键值对（通常删除末尾键值对）　　

　　　　参数：无

　　　　返回值：元祖

>>> aDict = {'name': 'zjs', 'age': 12, 'sex': 'male'}
>>> aDict.popitem()
('sex', 'male')
>>> print(aDict)
{'name': 'zjs', 'age': 12}

10.setdefault(self, k, d=None)　　---->设置k的缺省值如果d未指定则默认为None

　　　　参数：无

　　　　返回值：无

>>> aDict = {'name': 'zjs', 'age': 12, 'sex': 'male'}
>>> aDict.setdefault('a')
>>> print(aDict)
{'name': 'zjs', 'age': 12, 'sex': 'male', 'a': None}

11.fromkeys(*args, **kwargs)　　@staticmethod 　　---->fromkeys()为静态方法，可以不声明对象直接调用

　　　　参数：任意

　　　　返回值：字典

seq = ('name', 'age', 'sex')

dict = dict.fromkeys(seq)
print ("新的字典为 : %s" %  str(dict))

dict = dict.fromkeys(seq, 10)
print ("新的字典为 : %s" %  str(dict))

　　输出：

新的字典为 : {'age': None, 'name': None, 'sex': None}
新的字典为 : {'age': 10, 'name': 10, 'sex': 10}

（2）访问字典里的值

由于字典中的键值对是无序的。所以不能使用下标来访问字典内的值，只能通过键来查找所对应的值

aDict = {'name': 'zjs', 'age': 12, 'sex': 'male'}

print(aDict['name'])
print(aDict.get('age'))

　　输出：

zjs
12

使用get与索引方式访问字典的值的区别是：如果访问一个不存在的键使用索引方式会报错，而get方法不会报错。除非get方法中指定一个默认值，否则返回None

（3）修改字典里的值

字典的值只能通过键值来修改

aDict = {'name': 'zjs', 'age': 12, 'sex': 'male'}
aDict['name'] = 'zhang'
print(aDict)

　　输出：

{'sex': 'male', 'name': 'zhang', 'age': 12}

（4）删除字典的元素

aDict = {'name': 'zjs', 'age': 12, 'sex': 'male', 'grade': 3, 'six': 6}
del aDict['name']   #删除指定键的键值对 若键不存在则会抛出异常
print(aDict)
t1 = aDict.pop('six')   #删除指定的key对应的键值对返回key对应的值，若指定的key不存在则返回指定的缺省值默认为None
print('删除的元素为：', t1)
print(aDict)
t2 = aDict.popitem()    #随机删除一个 并返回删除的元素
print('删除的键为：', t2)
aDict.clear()  #无论字典中有多少键值对都全部删除
print(aDict)

　　输出：

{'sex': 'male', 'age': 12, 'grade': 3, 'six': 6}
删除的元素为： 6
{'sex': 'male', 'age': 12, 'grade': 3}
删除的键为： ('sex', 'male')
{}

（5）字典的遍历

　　1.通过键来遍历：

dict1 = {'name': 'zjs', 'age':12, 'sex':'male'}

for item in dict1:
    print(item,dict1[item])

　　输出：

name zjs
sex male
age 12

　　等价于：

for item in dict1.keys():
    print(item, dict1[item])

　　输出：

name zjs
age 12
sex male

　　2.只获取字典的值：

dict1 = {'name': 'zjs', 'age':12, 'sex':'male'}

for item in dict1.values():
    print(item)

　　输出：

12
zjs
male

　　3.对字典的键值的获取：

dict1 = {'name': 'zjs', 'age':12, 'sex':'male'}

for key, value in dict1.items():
    print(key, value)

　　输出：

sex male
age 12
name zjs

（6）字典的特性

• 字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
• 两个重要的点需要记住：

　　　　1）不允许同一个键出现两次。创建时如果同一个键被赋值多次，只有最后一个值会被记住。

　　　　2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行。

　　　　1.实例：

dict1 = {'name': 'zjs', 'Age': 7, 'name': 'zhang'}
print(dict1)

dict2 = {True: 'b', 1.0: 'a', 1: 'c'}
print(dict2)

　　　　输出：

{'name': 'zhang', 'Age': 7}
{True: 'c'}

　　　　2.实例：

dict1 = {['Name']: 'zjs', 'Age': 12}

print (dict1)

　　　　输出：

Traceback (most recent call last):
  File "E:/zjs/Python/pythonTest/day01/day01/d1.py", line 73, in <module>
    dict1 = {['Name']: 'zjs', 'Age': 12}
TypeError: unhashable type: 'list'

6、集合：set

　　集合（set）是一个无序的不重复元素的序列。

　　基本功能是进行成员关系测试和删除重复元素。

　　可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

set1 = {1,2,3,4,5,3,'a','zjs',(1,3,'q')}

　　或

set1 = set([1,2,3,4])

　　不可变集合使用frozenset()：

frozenset1 = frozenset([1,2,3,4])

　　（1）集合的常用方法

# set可以进行集合运算
a = set('zjs')
b = set('zhang')
 
print(a)
 
print(a - b)     # a和b的差集
 
print(a | b)     # a和b的并集
 
print(a & b)     # a和b的交集
 
print(a ^ b)     # a和b中不同时存在的元素

　　输出：

{'d', 'r', 'c', 'a', 'b'}
{'b', 'r', 'd'}
{'b', 'z', 'd', 'l', 'c', 'r', 'm', 'a'}
{'c', 'a'}
{'b', 'z', 'd', 'l', 'r', 'm'}

7、布尔值：bool

bool类型是int的子类

只有 True （真）和 False （假）两个值

只有 '' （空字符串）、""（空字符串）、None（空值）、0（数字零）、 0.0（浮点数0.0）、[]（空列表）、()（空元祖）、{}（空字典）为False其余所有值都为True