第二章:核心对象、变量、输入和输出
2.1 数值
2.1.1
数值,python中的数值主要有两种，一种是整型一种是浮点型
整型是没有小数点的，浮点型是有小数点的
2.1.2
python中基本的运算符:+,-,*/
特别注意/这个运算符,除法运算的结果是一个浮点型，即使它的结果是整数
2.1.3
python中的输出语句
print(n),输出的是一个数字
如果想要多个数字输出，使用print(n,m,e,r…)这样使用,分开
print(1,2,3,4,5)
1 2 3 4 5
2.1.4 变量(c语言和java将的够清楚了，它的深层含义也清楚了)
变量的命名规则:
变量名必须以字母或者是下划线开头，并且变量名只能由字母、数字、下划线组成，
约定变量名的第一个首字母小写，其他的首字母都大写
speed=50
timeElapsed=14;
distance=speed*timeElapsed
print(distance) #可以看到，Python中数不需要像java那样声明变量的类型的
#因为python中认为数值型的基本数据类型有整型和浮点型(带小数点的就是浮点型，反之就是整型)
700
2.1.5
关于数值型数据处理的三个函数
abs(),int(),round()
abs():取绝对值
int():保留整数部分
round(m,r):对m的结果保留几位小数，4舍5入
a=2
b=3
print(abs(1-(4*b)))
print(int((a**b)+.8))
print(round(a/b,3))
11
8
0.667
2.1.6
python 中给变量赋值
增量赋值
+=，-+，*=，/=，**=
和javav语言没有区别
#增量赋值语句的使用
num1=6
num1+=7
num2=7
num2-=5
num3=8
num3/=2
print(num1,num2,round(num3))
13 2 4
2.1.7
关于数值处理的其他两种整型运算符
//(整除运算符) %(求余运算符)
对于两个整数,m,n,m除以n的商记作是m//n,m除以n的余记作是m%n
totalInches=41
feet=totalInches//12
inches=totalInches%12
print(feet,inches)
3 5
python中的优先级
一句话，尽量使用括号，这样就不用记那些优先级了execise 2.1
#61
revenue=98456
costs=45000
profit=revenue-costs
print(profit)
53456
#63
price=19.95
discountPercent=30
markdown=price*(discountPercent/100)
price-=markdown
print(round(price,2))
13.96
#65
balance=100
balance+=balance*0.05
balance+=balance*0.05
balance+=balance*0.05
print(round(balance,2))
115.76
load=1.68e+13
popularity=3.1588e+10
avg=load/popularity
print(round(avg))
532
2.2 字符串
2.2.1 字符串字面量
是由字符构成的一个序列，并且视为一个整体
在python当中使用一对单引号括起来或者是一对双引号来表示字符串
注意:当使用双引号的时候字符串里面不能出现双引号但是可以出现单引号
当使用单引号的时候，字符串中不可以出现单引号但是可以出现双引号2.2.2变量，可以将字符串赋给一个变量
这和java类似2.2.3
字符串的索引和切片
索引:字符串中字符在字符串中都有对应的位置，所以可以通过位置来访问
例如:str=“hello world” 和java一样
切片:获得字符串中的一个子字符串
str[m:n],从m位置开始到n-1所有的字符序列都返回
如果m>=n，返回空字符串
如果想要返回子字符串在主字符串中首次出现的位置，可以使用str.find(substr)和str.rfind(substr)
这两个函数
一个是从左到右搜索，一个是从右到左搜索，返回所在的位置，如果没有则返回-1、
#字符串切片和索引的使用
print("Python")
print("Python"[1],"Python"[5],"Python"[2:4])
str1="Hello World!"
print(str1.find('W'))
print(str1.find('x'))
print(str1.rfind('l'))
2.2.4
反向索引，字符串可以从左到右索引，也可以从右到左索引
从右边开始到左边，-1：n
2.2.5切片的默认边界
在切片的时候，可以省略一端
例如str[:n] 包括了从字符串的开始到n-1所有的字符
str[m:]包括了从m开始到整个字符串结束的所有字符
而切片str[:]正好显示了整个字符串
#反向索引和默认切片边界的使用
print("Python")
print("Python"[-1],"Python"[-4],"Python"[-5:-2])
print("Python"[-3:],"Python"[:-3])
2.2.6 字符串的连接
字符串的连接：+
字符串的重复：str*n ，就可以将字符串重复n次
2.2.7 字符串处理常用的方法
- str.find(substr) 从左边开始寻找子字符串第一次出现的位置
- str.rfind(substr) 从右边开始寻找子字符串第一次出现的位置
- len(str) 返回字符串的长度
- str.upper() 全部变大写
- str.lower() 全部变小写
- str.count(substr) 非重叠子字符串的数目
- str.capitalize() 字符串首字母大写，其他的小写
- str.title() 字符串中每个单词的首字母大写，其他的小写
- str.rstrip() 移除字符串末尾的空白字符串
2.2.10
input函数
一般使用的格式是
variableName=input(prompt) #prompt是一个提示性的语句，提示输入的信息
fullname=input('Enter a full name:') #Franklin Delano Roosevelt
n=fullname.rfind(" ") #从右往左寻找第一个出现" "的位置
print("Last name:"+fullname[n+1:])
print("First name:"+fullname[:n])
Enter a full name: Franklin Delano Roosevelt
Last name:Roosevelt
First name:Franklin Delano
2.2.11 int(str), float(str) eval(str )
解析:
int(str) 将字符串的内容转换为整型
float(str) 将字符串的内容转换为浮点型
eval(str) 将字符串的内容计算，赋值为合适的整型或者是浮点型
这三个函数的主要用处
一个input函数筒长会返回一个字符串，我们通过使用int(str),float(str),eval(str)函数可以将它
转换成为数字
#int(str),float(str),eval(str)函数的应用
age=int(input("Enter your age:"))
print("your age:",age)
age=float(input("Enter your age"))
print("your age :",age)
age=eval(input("Enter your age"))
#注意，在int()函数中应该输入的是整数，不然就会报错，而其他的不会
Enter your age:3
your age: 3
Enter your age12
your age : 12.0
Enter your age13
str(num) 函数可以将一个数字转换成为字符串
在python当中数字和字符串是不可以连接的，但是将数字通过str()函数转换成为字符串
之后就可以和字符串连接了
同时，int()函数和float()函数还可以用在数值型，但是eval()不可以使用在数值型数据
numVar=input("Enter your name")
print(numVar+str(20))
Enter your name10
1020
python中需要注意的一些东西
1:一行代码写不下，可以在行尾加上
2:也可以在（）中将想要写的代码写在里面
#字符串的使用
编写一个程序，将一个百分比转换成为一个小数
str=input("Enter percentage:")
str1=str[:-1] #丢弃最后一个百分号
print(" Equivalent decimal:",round(eval(str1)/100,2))
Enter percentage:125%
Equivalent decimal: 1.25
单词替换 编写一个程序，要求输入一个句子，以及句子当中的一个单词和另外一个单词，然后显示用第二个单词替换第一个单词之后的句子
str1=input("Enter a sentence:")
str2=input("Enter word to replace:")
str3=input("Enter replacement word:")
n=str1.find(str2) #找到了出现的位置
print(str1[:n-1],str3,str1[len(str2)+1:])
Enter a sentence:What you don't know won't hurt you.
Enter word to replace:know
Enter replacement word:owe
What you don't owe you don't know won't hurt you.
2.3输出
2.3.1
通过两个卡选参数的print()函数和format()函数可以让输出更加丰富
print(v1,v2,v3,v4,vn)
将依次显示每一个值，并且用空格将他们分开
1.可以通过使用sep这个参数实现任意的分开形式
2.当使用print()之后，就会将光标自动转换到下一行，如果还想在
同一行输入，使用end这个参数，就end这个参数里面的值代替了回车和换行
#print() sep和end 的使用
print("a","b")
print("a","b",sep="**")
print("hello",end=" ")
print("world!")
a b
a**b
hello world!
2.3.3转义序列
转义序列是位于字符串当中的短序列，用于指示光标或者允许一些特殊字符的输出
告诉程序，这只是一个普通的字符，没有特殊的含义
此外，int(),float(),eval()在作用到含有换行符的字符串的时候，他们会忽略换行符
例如,int(“7\n”)结果还是7
2.3.4
域内输出对其
长须输出经常需要以固定的宽度一列一列的显示输出.ljust(n)、rjust(n)、center(n)方法可以用宽度为n的域，分别按照左对齐，右对齐和居中输出
如果一个字符串的宽度小于指定的宽度,字符串的左边、右边或者是两边会以空格的形式输出，如果大于，将会失效
并且还要注意，这些只适用于字符串，那么问题是我想要使用在数值上面怎么办，那就使用str()函数转换为字符串
#域内对其输出的举例
a=5
print(str(a).center(10))
5
format()方法,它可以将数据按照指定的格式转换
format()方法比ljust(),rjust(),center()方法的使用范围广
format()方法可以接受任何类型的数据
字符串的参数使用{NUM}进行表示,0, 表示第一个参数,1, 表示第二个参数, 以后顺次递加;
使用":", 指定代表元素需要的操作, 如":.3"小数点三位, ":8"占8个字符空间等;
使用format的时候需要有一个槽来和它匹配
还可以添加特定的字母, 如:
‘b’ - 二进制. 将数字以2为基数进行输出.
‘c’ - 字符. 在打印之前将整数转换成对应的Unicode字符串.
‘d’ - 十进制整数. 将数字以10为基数进行输出.
‘o’ - 八进制. 将数字以8为基数进行输出.
‘x’ - 十六进制. 将数字以16为基数进行输出, 9以上的位数用小写字母.
‘e’ - 幂符号. 用科学计数法打印数字, 用’e’表示幂.
‘g’ - 一般格式. 将数值以fixed-point格式输出. 当数值特别大的时候, 用幂形式打印.
‘n’ - 数字. 当值为整数时和’d’相同, 值为浮点数时和’g’相同. 不同的是它会根据区域设置插入数字分隔符.
‘%’ - 百分数. 将数值乘以100然后以fixed-point(‘f’)格式打印, 值后面会有一个百分号.
‘s’-字符串
{num:[[对齐方式][宽度][数据的形式]][.精度]}
num:代表的是format()里面的参数
注意:一般情况下，数据的形式是不可以省略的
#format()函数的使用举例
print("The area of {0:s} is {1:d} square miles.".format("Texas",268820))
str1="The population of {0:s} is {1:.2%} of the U.S population"
print(str1.format("Texas",26448000/309000000))
The area of Texas is 268820 square miles.
The population of Texas is 8.56% of the U.S population
2.4 列表、元组
python中的核心对象是数值，字符串，列表，元组，文件，集合和字典
2.4.1
列表(list):列表是python对象的一个有序序列，其中的对象可以是任何类型，并不要求类型一致
列表的创建:使用[]将列表中的元素括起来即可
#列表的创建
team=["Seahawks",2014,"CenturyLink Field"]
15 个列表的常用方法
1: len(list) 列表中元素的个数
2: max(list) 最大值(元素必须是相同的类型)
3: min(list) 最小值(元素必须是相同的类型)
4: sum(list) 求和(必须是数字)
5: list.count(obj) 一个对象在列表当中出现的次数
6: list.index(obj) 一个对象在列表中首次出现的位置
7: list.reverse() 将列表中的元素逆序
8: list.clear() 将列表清空
9: list.append(obj) 在列表的末端插入一个对象
10: list.extend(list1) 在列表的末端插入新列表中所有的元素
11: del list[post] 删除列表中某一个位置上的对象
12: remove list(obj) 移除列表中首次出现的对象
13: list.insert(pos,obj) 在list的post位置插入对象obj
14: list1+list2 将两个列表对象连接
15： list*n 列表对象重复多少次
同样的，和字符串类似，python当中的列表也可以是正向索引和逆向索引
还有一点就是字符串当中的数值是不可以被更改的，但是列表中的数值是可以被更改的
#列表的使用
grades=[]
num=float(input("Enter the first grade"))
grades.append(num)
num=float(input("Enter the second grade"))
grades.append(num)
num=float(input("Enter the third grade"))
grades.append(num)
num=float(input("Enter the forth grade"))
grades.append(num)
num=float(input("Enter the fifth grade"))
grades.append(num)
mingrade=min(grades)
grades.remove(mingrade)
mingrade=min(grades)
grades.remove(mingrade)
avg=sum(grades)/len(grades)
print("Average Grade:{0:.2f}".format(avg))
Enter the first grade89
Enter the second grade77
Enter the third grade82
Enter the forth grade95
Enter the fifth grade81
Average Grade:88.67
2.4.2 切片 和字符串的切片一样
至此，我们已经两次接触到了切片
那么到底什么是切片,切片就是返回一个序列当中的子序列
如果字符串的切片，返回的就是一个子字符串或者是字符
如果是列表的切片，返回的就是一个列表的子列表或者是元素
举一反三:既然都是同一种类型，那么切片返回来的数值对相应的对象的方法也是使用的
2.4.3
split和join方法
使用这两种方法可以在字符串和列表当中互相转换
list=str.split(regenx)
split()将字符串按照指定的分隔符将字符串划分成为一个个子字符串，转换成为列表中的元素
如果没有指定分隔符的时候，python默认是空白(空格，换行，制表符组成的任意字符串)
join方法
str=“regenx”.join(list)
将list里面的元素通过"regenx"连接，然后显示出来
#split和join方法的使用
print("a,b,c".split(","))
['a', 'b', 'c']
line=["To","be","or","not","to","be"]
print(" ".join(line))
krispies=["Snap","Crackle","Pop"]
print(",".join(krispies))
To be or not to be
Snap,Crackle,Pop
2.4.5 元组对象
元组和列表类似，是一个有序的对象。但是不同的是元组不可以直接被修改,append(),extend(),insert()这里是对元组对象不适用的
del list[] remove()也是对元组对象不适用的，其他的都可以
元组使用一组()来表示
但是打印输出的时候总是会带着这个()
列表也是如此
同样的，也可以索引和切片
元组也可以是直接暴漏在外面
例如
t=1,2,3,4
这就代表的是一个元组对象
t=["hello","World!"]
print(t)
t=("hello","World!")
print(t)
['hello', 'World!']
('hello', 'World!')
#交换数值,使用元组将值交换
x=5
y=6
x,y=y,x #这里代表的元组，元组是一个对象，可以赋值
print(x,y)
6 5
t=["hello"]
t1=t
print(t1)
['hello']
2.4.6
嵌套列表
列表和元组中的元素可以是数值，字符串，也可以是列表，也可以是元组，那么利用他们的特性索引
就很类似于二维数组的意思了
#列表当中的元素多元化
region=[("Northeast",55.3),("Midwest",66.9),
("South",114.6),("West",71.9)]
print("the 2010 population of the",region[1][0],"was",region[1][1],"million")
totalPop=region[0][1]+region[1][1]+region[2][1]+region[3][1]
print("Total 2010 popualation of th US:{0:.1f} million.".format(totalPop))
the 2010 population of the Midwest was 66.9 million
Total 2010 popualation of th US:308.7 million.
2.4.7 不可变和可变对象
python中对象的理解
对象是一个可以存储数据并且有操纵数据的操作方法的实体
数值,字符串,列表,元组都是对象
当地个变量使用赋值语句创建出来之后，等号右边的值就变成了内存中的一个对象
而这个变量就是指向这个内存的引用变量(类似于指针)
在python当中，当改变一个列表的时候，这个变化是作用在列表内存位置的对象的
但是如果一个变量要改变它的值，并且这个值是数值，字符串或者是元组的时候，python会自动分配
一个新的位置来存储，，并且将变量引用到新的对象上
即:列表,可以原地修改，但是数值，字符串，元组不可以
#例如
L=[5,6]
n=2
s="Python"
t=('a','b','c')
L.append(7)
n+=1
s=s.upper()
t=t[1:]
#除了列表的引用变量没有改变，其他的所有的都改变了
2.4.8 列表复制
列表的复制有两种方法
1:使用引用变量，让两个变量指向同一个对象
(但是这里可能会出现麻烦,一个变量对对象的操作会影响到另一个变量)
var2=var1
2:将值给它，而不是地址，这样的话，就会给两个变量创建互相不影响的内存空间
var2=list(var1)
或
var2=var1[:]
#列表的复制举例
#相互影响的列表复制
list1=['a','b']
list2=list1
list2.append('c')
print(list1)
['a', 'b', 'c']
#列表的复制
list1=['a','b','c']
list2=list(list1)
list2.append('d')
print(list1)
print(list2)
['a', 'b', 'c']
['a', 'b', 'c', 'd']
2.4.9
索引,删除和切片越界
python当中不允许列表和元组中的单个元素月结，但是切片中可以允许索引越界
如果切片的左边的索引太小的话，切片会从列表的第一项开始，如果切片右边的索引太大的话，切片会以知道列表的最后一项
#举例，元素的越界和切片的越界
list1=[1,2,3,4,5]
print(list1[7])
list1[-10:2]
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-16-ff91a4ccffde> in <module>
1 #举例，元素的越界和切片的越界
2 list1=[1,2,3,4,5]
----> 3 print(list1[7])
4 list1[-10:2]
IndexError: list index out of range
扫一扫
9078
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
