pythonh打卡第一天
#1，变量
#2，运算符
##1，算术运算符
##2，比较运算符
##3，赋值运算符
##4，位运算符
##5，运算符优先级
#3，数据类型
##1，Number（数字）
##2，String（字符串）
##3，List（列表）
##4，Tuple（元组）
##5，Set（集合）
##6，Dictionary（字典）
1，变量
Python 中的变量赋值不需要类型声明。每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。`每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
代码：
#单变量赋值
a=12 #整型变量
b=12.0#浮点型
c="name"#字符串
#多变量赋相同值
d=e=f=13
#多变量赋不同值
x,y,z=1,10.0,"why"
print(a,'\n',b,'\n',c,'\n',d,'\n',e,'\n',f,'\n',x,'\n',y,'\n',z)结果：
12
12.0
name
13
13
13
1
10.0
why2，运算符
1，算术运算符（+，-，*，/，%，**，//）
代码：
#算术运算符
a=10
b=6
c=0
c=a+b
print("1,c的值为",c)#加
c=a-b
print("2,c的值为",c)#减
c=a*b
print("3,c的值为",c)#乘
c=a/b
print("4,c的值为",c)#除
c=a%b
print("5,c的值为",c)#取余
c=a**b
print("7,c的值为",c)#幂
c=a//b
print("8,c的值为",c)#取整结果：
1,c的值为 16
2,c的值为 4
3,c的值为 60
4,c的值为 1.6666666666666667
5,c的值为 4
7,c的值为 1000000
8,c的值为 12，比较运算符（==，!=，<>，>,<,>=,<=）
特别注意<>类似于！=
3，赋值运算符（=，+=，-=，*=，/=，%=，**=，//=）
类似算术运算符，一般格式为c+=a,即把c+a赋值给c，其余类似
4，位运算符（&，|，^,~,<<,>>）
| & | 参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 |
|---|---|
| 只要对应的二个二进位有一个为1时，结果位就为1。 | |
| ^ | 当两对应的二进位相异时，结果为1 |
| ~ | 对数据的每个二进制位取反,即把1变为0,把0变为1 。 |
| << | 运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。 |
| >> | 把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数 |
上面空格处为“|”
代码：
#位运算符
a=60 # 60=00111100
b=13 # 13=00001101
c=0
c=a&b #12=00001100
print(c)
c=a|b #61=00111101
print(c)
c=a^b #49=00110001
print(c)
c=~a #-61=-11000011
print(c)
c=a<<2 #240=11110000
print(c)
c=a>>2 #15=00001111
print(c)结果：
12
61
49
-61
240
155，运算符优先级
从高到低依次为：指数；按位翻转；乘，除，取模和取整除；加法减法；右移，左移运算符；位 'AND；位运算符；比较运算符；等于运算符；赋值运算符；即：
*，~， / % //，+ -，>> <<，&，^ |,<= < > >=,<> == ！=，= %= /= //= -= += *= **=
代码为：
#运算符优先级
a=10
b=8
c=6
d=4
e=2
f=0
f=a+b*c/d//e
print("f=a+b*c/d//e的值为：",f)
f=(a+b)*c/d//e
print("f=(a+b)*c/d//e的值为：",f)
f=(a+b)//e*c/d
print("f=(a+b)//e*c/d的值为：",f)结果为：
f=a+b*c/d//e的值为： 16.0
f=(a+b)*c/d//e的值为： 13.0
f=(a+b)//e*c/d的值为： 13.53，数据类型
1，Number（数字）（ int、float、bool、complex（复数））
代码：
a,b,c,d=20,5.5,True,4+3j
print(type(a),type(b),type(c),type(d))#type函数用以查询变量类型结果为：
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>2，String（字符串）
加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，紧跟的数字为复制的次数
代码为：
#String
str="qwert"
print(str) # 输出字符串
print(str[2]) # 输出第一个到倒数第二个的所有字符
print(str[0:-1]) # 输出字符串第一个字符
print(str[0:2]) # 输出从第三个开始到第五个的字符
print(str[2:]) # 输出从第三个开始的后的所有字符
print(str*2) # 输出字符串两次
print(str+"yuiop") # 输出字符串两次结果为：
qwert
e
qwer
qw
ert
qwertqwert
qwertyuiop特别注意：Python 字符串不能被改变
代码：
str="qwert"
str[0]="e"结果：
Traceback (most recent call last):
File "D:/Enclosure/python/firstday/shujileixing.py", line 17, in <module>
str[0]="e"
TypeError: 'str' object does not support item assignment3，List(列表)
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。加号 + 是列表连接运算符，星号 * 是重复操作.
代码为：
list = ['abcd', 786, 23, 'qwwer', 79]
tinylist = [123, 'qwer']
print(list) # 输出完整列表
print(list[0]) # 输出列表第一个元素
print(list[0:-1]) #输出第一个到倒数第二个的所有元素
print(list[1:3]) # 从第二个开始输出到第三个元素
print(list[2:]) # 输出从第三个元素开始的所有元素
print(tinylist * 2) # 输出两次列表
print(list + tinylist) # 连接列表结果为：
['abcd', 786, 23, 'qwwer', 79]
abcd
['abcd', 786, 23, 'qwwer']
[786, 23]
[23, 'qwwer', 79]
[123, 'qwer', 123, 'qwer']
['abcd', 786, 23, 'qwwer', 79, 123, 'qwer']与Python字符串不一样的是，列表中的元素是可以改变的：
代码为：
list = ['abcd', 786, 23, 'qwwer', 79]
list[0]="zxcvb"
print(list)结果为：
['zxcvb', 786, 23, 'qwwer', 79]4，Tuple（元组）
元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。元组中的元素类型也可以不相同：
代码为：
#元组
tuple= ('abcd', 786, 23, 'qwwer', 79)
tinytuple = (123, 'qwer')
print(tuple) # 输出完整元组
print(tuple[0]) # 输出元组第一个元素
print(tuple[0:-1]) #输出第一个到倒数第二个的所有元素
print(tuple[1:3]) # 从第二个开始输出到第三个元素
print(tuple[2:]) # 输出从第三个元素开始的所有元素
print(tinytuple * 2) # 输出两次元组
print(tuple + tinytuple) # 连接元组结果为：
('abcd', 786, 23, 'qwwer', 79)
abcd
('abcd', 786, 23, 'qwwer')
(786, 23)
(23, 'qwwer', 79)
(123, 'qwer', 123, 'qwer')
('abcd', 786, 23, 'qwwer', 79, 123, 'qwer')
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号5，Set（集合）
集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
代码为
#集合
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student) # 输出集合，重复的元素被自动去掉
# 成员测试
if 'Rose' in student:
print('Rose 在集合中')
else:
print('Rose 不在集合中')
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b) # a 和 b 的差集
print(a | b) # a 和 b 的并集
print(a & b) # a 和 b 的交集
print(a ^ b) # a 和 b 中不同时存在的元素结果为
{'Jack', 'Tom', 'Mary', 'Rose', 'Jim'}
Rose 在集合中
{'r', 'a', 'c', 'b', 'd'}
{'r', 'b', 'd'}
{'a', 'd', 'm', 'l', 'r', 'z', 'c', 'b'}
{'a', 'c'}
{'d', 'm', 'l', 'r', 'z', 'b'}6，Dictionary（字典）
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。
代码为
dict={'name':'tom','age':23,'sex':'man'}
print(dict.keys())#输出字典的所有键
print(dict.values())#输出字典所有值结果为
dict_keys(['name', 'age', 'sex'])
dict_values(['tom', 23, 'man'])