第一个程序
print("hello world")
变量:变量在程序中就是一个容器。(用来装东西,去超市买东西时候推得手推车就是变量)
score=100 #定义一个变量,这个变量名字就score,它里面存储的一个数值100
high=180 #定义一个变量,变量值是180
注释:#井号为注释号 /多行注释''''''
一.基本数据类型
python(数据类型)主要有6中数据类型:
Number(数字)、String(字符串)、List(列表)、Tuple(元组)、Dictionary(字典)、Set(集合)
其中number数字类型支持 int、float、bool、complex(复数)。
(1)numbers 数字
整型 int
a = 1
print(type(a))>>> 2 ** 100
1267650600228229401496703205376L
布尔型 boor
True False
print (1 > 2)print (1 < 2)
浮点型 float
a = 1.0
print (type(a))
复数 complex
6.23+1.5j -1.23-987j
(2)字符串 str
name="wuchuan"
print(type(name))
(3)列表(list)
列表是Python 中使用最频繁的数据类型。列表是写在方括号[ ]之间、用逗号分隔开的元素列表。列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)。
特点:支持对列表进行修改/删除/插入元素操作,[ ]内为空或者只有单个/多个元素,都为列表。
list_1=[]
list_2= [1]
list_3= ["zhangsan","lisi","wangwu"]
list_4=['guangdong','guangxi',['shenzhen','zhuhai']]print(list_1, list_3 ,list_4)
(4)元组(tuple)
元组与列表类似,不同之处在于元组的元素不能修改;元组的元素写在小括号()里,元素之间用逗号隔开。
注意:括号内为空时,则是一个空元组。
括号内只有一个元素时,则不为元组,由括号内元素类型定义
要想实现括号内只有一个元素的元组,则需要在该元素后面加入逗号","
tup_1=()
tup_5=("zhangsan","lisi","wangwu")
tup_2=(1)
tup_3=('ni')
tup_4=([2])print(type(tup_1))print(type(tup_5))print(type(tup_2))print(type(tup_3))print(type(tup_4))
(5)字典(dict)
字典是一个有键值对组成的数据类型;用大括号{ }来表示一个字典。字典括号内为键值对格式 如{"key1":"value1","key2":"value2"}。支持对字典进行修改/删除/插入元素操作。
创建一个空字典,直接在变量名后面加上一个花括号{ }
dic_1= {"name":"zhangsan","age":28,"sex":"boy"}
dic_2= {"name1":"zhangsan","age":{"age1":"18","age2":20},"name2":"lisi","name3":"wangwu"}print(dic_1)print (type(dic_1))
(6)集合(set)
集合是写在花括号 { } 里面或者 set() 函数创建集合;用逗号 , 分隔开。
注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
a = {1,2,3}print(a)print(type(a))
d={}print(type(set(d)))
二.数据类型的转换
1,整型转换为字符串用str()函数
(int转str )
c=123d=str(c)#通过变量赋值print(type(d))
a = 123
print(str(a))print (type(str(a)))
2.转化为整型用int()函数(str转int)
a = "123"b=int(a)print(type(a))print(type(b))
3.list() 方法用于将元组或字符串转换为列表。
(str转list)
a="123"b=list(a)print(type(a))print(type(b))
(tuple转list)
a = (1,2,3)print(list(a))print (type(list(a)))
(set转list)
a={"shenzhen","foshan","xianggan"}
b=list(a)print(type(a))print(type(b))
4. tuple() 可以将字符串,列表,字典,集合转化为元组;
(str转tuple)
a="2343"b=tuple(a)print(type(b))
(list转tuple)
a=["shenzhe","dongguang",40,23]
b=tuple(a)print(type(b))
(dict转tuple)
a={"name":"shenzhe","age":40}
b=tuple(a)print(b)#将字段转换为元组时候只保留键!
print(type(b))
(set转tuple)
a={"shenzhen","foshan","xianggan"}
b=tuple(a)print(type(b))
5.set() 可以将字列表,元组,转化为集合
(list转set)
a=[1,2,4,4]
b=set(a)#set()函数有去重功能,把重复的元素去掉
print(type(b))
(tuple转set)
a=('huawei','sanxing','apple')
b=set(a)print(type(b))
(dict 转 set)
a={"shenzhen":"nanshan","foshan":"nanhai"}
b=set(a)print(b)#取键
print(type(b))
三、运算符
1.算数运算符
(1)加(+)
注意:字符串与整数之间不能进行相加,需要通过str()或int()进行转换数据类型
整数与整数相加
a="3"b=4b=str(b)print(a+b)
浮点数与浮点数相加
"""二进制存储精度误差"""
a=3.6b=4.44
print(a+b)
整数与浮点数相加
字符串之间相加
a="hello"b="shenzhen"
print(a+b)
正数与负数相加
(2)减(-)
注意:字符串与整数和字符串之间不能进行相减
整数与整数相减
>>> 10 - 5
5
负数与负数相减
>>> -3 - -4
1
正数与负数相减
浮点数与浮点数相减
整数与浮点数相减
(3)乘(*)
注意:字符串与字符串之间不能进行相乘
整数与整数相乘
>>> 3 * 2
6
浮点数与浮点数相乘
整数与浮点数相乘
正数与负数相乘
负数与负数相乘
(4)除(/)
注意:字符串与字符串和整数之间不能进行相除
"""整数相除,结果为整数"""
python2.x 整数与整数相除>>> 6 / 3
2
"""整数相除,结果为浮点数"""
python3.x 整数与整数相除>>> 6/3
2.0
浮点数与浮点数相除
整数与浮点数相除
(5)求幂(**)
如x ** y --> 返回x的y次幂
>>> 3 ** 3
27
>>> 10 ** 2
100
(6)取模 (%)--> 返回除法的余数
>>> 5 % 3
2
"""-a % b = b - (a % b)"""
>>> -304 % 100
96
(7)整除法(//) -->向左取整
正数(正数向零取整)
>>> 9.0 // 2
4.0
负数(负数取偏小一位数)
>>> -9.0 // 2
-5.0
>>> -9 // 2
-5
注意:
1.先乘除后加减
2. 幂运算优先级最高
2.赋值运算符
(1)=等号是主要的赋值运算符
变量的使用和命名
变量名只能包含字母、数字和下划线,可以以字母或下划线打头,但是不能以数字打头
变量不能包含空格
不要以 python 中的关键字(保留字符)作为变量
变量名应简短又具有描述性
变量区分大小写
name = "Alex Li"name2=nameprint(name,name2)
name= "Jack"
print(name)
python内存回收机制如下:
变量相当于门牌号,当门牌没有了,即函数的引用都没有调用了,内存的数据就会被清除掉。
python内有个定时器,定期的会刷新,如果发现内存中数据不被引用了,就会被回收,这个就是内存的回收机制。
(2)+= 加法赋值运算符
a += 1 --> a = a + 1
a=3a+=1
print(a)
(3)-= 减法赋值运算符
a -= 1 --> a = a – 1
a=10a-=1a=a-1
print(a)
(4)*= 乘法赋值运算符
a *= 1 --> a = a * 1
(5)/= 除法赋值运算符
a /= 2 --> a = a / 2
(6)%= 取模赋值运算符
a %= 3 --> a = a % 3
(7)**= 幂赋值运算符
c **= a 等效于 c = c ** a
(8)//= 取整除赋值运算符
c //= a 等效于 c = c // a
3.比较运算符(返回值为Boolean值----布尔值)
(1)== 等于 - 比较对象是否相等
>>> "name" == "name"True>>> 1 == 1True>>> 1 == 2False
(2)!=或<> 不等于 - 比较两个对象是否不相等
>>> 1 != 2True>>> 1 <> 1False>>> "name" != "name1"True
(3)> 大于
>>> 2 > 1True>>> 5 > 8False>>> "shenzhen">"shenzhe"True
(4)< 小于
>>> 1 < 2True>>> 3 < 2False
(5)>= 大于等于
>>> 2 >= 2True
(6)<= 小于等于
>>> 2 <= 2True
注意:字符串按位比较,两个字符串第一位字符的ascii码谁大,字符串就大,不再比较后面的;第一个字符相同就比第二个字符串,以此类推,需要注意的是空格的ascii码是32,空(null)的ascii码是0,大写字母和小写字母的ASCII不同
4.身份运算符(用于比较两个对象的存储单元--内存地址)
(1)is 是判断两个标识符是不是引用自一个内存地址
x is y,类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True,否则返回 False
>>> 1 is 1True>>> 1 is 2False
(2)is not 是判断两个标识符是不是引用自不同对象
x is not y, 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True,否则返回 False
>>> 1 is not 1False>>> 1 is not 2True
注意:
小整数对象池:python在执行的时候,为了节约空间,帮我们创建好了小整数对象池,[-5~256],都是固定的地址,不管你用不用,都会存在。
比如,a=5,b=5,id(a)和id(b)的地址都是小整数池中固定已经存在的地址,所以相等
但如果,a=1000,b=1000,这时会给a一个地址,也会给b一个地址,但他们都不相等。
5.逻辑运算符
(1)逻辑与(and):两边的表达式同时为真,结果才为真。
a=10b=30
print(a==9 and b==30)
Falseprint(a==10 and b==30)
True
(2)逻辑或(or):两边的表达式一个为真,结果就为真。一个为真,结果就为真。
a=10b=30
print(a==9 or b==30)print(a==10 or b==30)print(a==11 or b==31)
(3)逻辑非(not):用于取反表达式,真变假,假变真
b=30
print(not b==310)print(not b==30)
逻辑运算符的优先级:从左到右:() > not > and > or
计算:1>3 or
3>2 and 1=0 and not(7>2
or
3>5)
从左到右,先计算()里,7>2为True,则括号里为True,再看括号外面的not,则这一部分为false.
再先计算左边的and,3>2为True,则看1=0的布尔值,1=0为False,则3>2 and 1=0为False.
再计算 3>2 and 1=0 and not(7>2 or 3>5),已知3>2 and 1=0 为False, not(7>2 or 3>5)为False,则3>2 and 1=0 and not(7>2 or
3>5)为False。
最后看1>3为False,3>2 and 1=0
and not(7>2 or 3>5)为False,则整体为False.
6.成员运算符
(1)in:判断一个值是在另一个变量中
如下:a 在 b序列中则返回True,否则返回False
a=10b=[1,2,20,10]
c=(1,2,10)print(a inb)print(a in c)
(2)not in 判断一个值不在另一个变量中
如下:a 不在 b序列中则返回True,否则返回False
a=1b=[1,2,20,10]
c=(3,2,10)print(a not inb)print(a not in c)
结果:
False
True