ChaseDream
标题: 打基础~ [打印本页]
作者: 珍妮王小钰 时间: 2019-2-6 03:16
标题: 打基础~
78 tongji
85 概率
87 python:
SAS有online tutorial可以高效自学,SQL有SQLZOO可以练手https://www.1point3acres.com/bbs/thread-138105-1-1.htmlDA要求的Python和CS的不太一样。要用熟Pandas, Numpy,Matplotlib, SciKit-Learn这几个包
正在上edX的6001网课,讲算法的,用的Python,针对的是python和CS零基础的,很多练习和作业,感觉设计的特别好,听了一个月下来,感觉进步很大。
https://zhuanlan.zhihu.com/p/24546514
| Udacity上的CS101. 里边内容都是用Python教的。没一个知识点都紧跟着Python coding练习。我学下来感觉还是非常好的。如果有一定基础可以看看Learn Python the hard way。里边的code example我觉得还是非常好的! |
|
建议R的学习者查看DataCamp上的练习和教程。
对于Python学习者的建议是,尝试用《笨办法学Python》学习的同时看视频做练习。建议初学者查看Rodeo(被称为“Python到数据科学IDE”)。
Python入门的话推荐edx上MIT的那门6001x,打基础不错。
edX MIT 6001x and 60002xhttps://www.edx.org/course/introduction-to-computer-science-and-programming-using-python-0
https://www.edx.org/course/introduction-to-computational-thinking-and-data-science-2
作者: 珍妮王小钰 时间: 2019-2-7 07:17
ML:Multinomial distribution Classification
• What is mood of person in current minute? M={Happy, Sad}• Measure his/her actions every ten seconds: A={Cry, Jump, Laugh, Yell}
Data (D): {LLJLCY, JJLYJL, CCLLLJ,JJJJJJ}Bias (??): Probability table
LLJLCY: happy? .5X.5X.3X.5X.1= sad?:
10分:
beta分布介绍相信大家学过统计学的都对 正态分布 二项分布 均匀分布 等等很熟悉了,但是却鲜少有人去介绍beta分布的。
用一句话来说,beta分布可以看作一个概率的概率分布,当你不知道一个东西的具体概率是多少时,它可以给出了所有概率出现的可能性大小。
简单的解释:
https://www.cnblogs.com/shixisheng/p/7197623.html?utm_source=itdadao&utm_medium=referral
MAP /MLE:
极大似然假设与贝叶斯估计的区别:
最大似然估计只考虑某个模型能产生某个给定观察序列的概率。而未考虑该模型本身的概率。这点与贝叶斯估计区别。
Map与ML的区别:
最大后验估计是根据经验数据获得对难以观察的量的点估计。与最大似然估计类似,但是最大的不同时,最大后验估计的融入了要估计量的先验分布在其中。故最大后验估计可以看做规则化的最大似然估计。
极大后验MAP什么时候等于极大似然ML
不知道关于假设的任何概率,所有的hi假设拥有相同的概率,then MAP is Maximum Likelihood (hML极大似然假设),如果数据量足够大,最大后验概率和最大似然估计趋向于一致。
Map和朴素贝叶斯有什么关系
If independent attribute condition is satisfied, then vMAP = vNB 如果独立的属性条件是满足的vmap=vNB
、请描述极大似然估计 MLE 和最大后验估计 MAP 之间的区别。请解释为什么 MLE 比 MAP更容易过拟合。
MLE:取似然函数最大时的参数值为该参数的估计值,ymle=argmax[p(x|y)];MAP:取后验函数(似然与先验之积)最大时的参数值为该参数的估计值,ymap=argmax[p(x|y)p(y)]。因为MLE 只考虑训练数据拟合程度没有考虑先验知识,把错误点也加入模型中,导致过拟合。
作者: 珍妮王小钰 时间: 2019-2-7 08:29
即使学过机器学习的人,对机器学习中的MLE(极大似然估计)、MAP(最大后验估计)以及贝叶斯估计(Bayesian)仍有可能一知半解。对于一个基础模型,通常都可以从这三个角度去建模,比如对于逻辑回归(logistics Regression)来说:
MLE: logistics Regression
MAP: Regularized Logistics Regression
Bayesian: Bayesian Logistic Regression#
-----------------------------
multiple multi-variate probabli:
# acts=4 tunes=5 weather=7
how many??:
# prob entries= 4x5x7=140
# params= (of classes)2x139(likeli 1 class)+ (2-1)prior=279
features: acts , tunes ,weahter
#params= classesx Πi(values featuresj)-1
params to estimate likelihood: 2x(4-1)+2X(5-1)+2X(7-1)
#classnumber#actvals tunes weather
benefit of naive bayes: very fast learning and classifying.
作者: 珍妮王小钰 时间: 2019-2-11 13:14
87:数据类型~~
往下:shift+tab 执行
不动:ctrl+回车。

type(1.2-1): float(int,,,) 7%2 1 10%2 0
type("q") str ('a') ("hello'qin'...") 里面有‘ “用 三 引号”””。。。。“”“里面可换行噢。
print("\”\b”)
=””b

int("1")+1
2

bool:
type(TRue):
1<2+1
true
(1<2)+1:
1

变量:
tip: a,b=1,2赋值
for 循环
a+=1
a=a+1(计算逻辑是等号的右边先计算)(1+1=2被重新赋值到a)

PYthon 三大数据结构。
作者: 珍妮王小钰 时间: 2019-2-12 00:33
列表 增删查改(索引[],Append\)
list=
num=[1,2,3]
num
out: [1,2,3]
sum(num)
out:6
len(num)
out:3(个组合的集合

slice #查
num[0]
out:1
num[2]=num[len(num)-1]
out:3
num[-1]倒数第一个
num[-2]倒数第二个(2)
num[0:1]
num[0:2]
output:[1,2]
num[0:3]
output:[1,2,3]
num[0:]
[1,2,3]
num[1:]
[2,3]
num[:2]
[1,2]
num[-2:]
[2,3]
slice求和: num[0]+num[1]

#shift+tab : L.insert(index,object)
增#插入的索引位置,插入的值
num insert()
num.insert(1,4)
num
[1,4,2,3]
num.insert(4,5)不如 num.append(6)好
.append()尾巴只能一个,而这样可以多个: num+[8,9]

删:num.pop(1)
num
out:
num.pop()默认删除最后一个

改:
num[3]=4(把位置的东东改)num[4]=5

二维:
b=[[1,2],[3,4]]
--------------
name=['','','']
sex=['','','']
age=[12,14,15]
#嵌套:
info=[name,sex,age]
info
out:[['','',''],[],[]]
info[0][1]# name里面的第一个'XX'
row=[0]*3
row
out:[0,0,0]
[row]*4
put:[[0,0,0],[0,0,0],[0,0,0],[0,0,0]]
列表
list.append(var) #列表尾添加
list.insert(index,var) #列表插入
list.extend(list1) #列表连接
list.remove(var) #删除var
list.pop(var) #删除最后一个
list.count(var) #计算个数
list.index(var) #找到第一个就返回索引
list.sort() #排序,assic首字母来排序
list.reverse() #倒序
作者: 珍妮王小钰 时间: 2019-2-12 14:20
#set集合化(&)去重功能 a=[1,2,3,3,4]
set(a)
out:{1,2,3,4}
------------------
#这样可以索引
list(set(a))[1] )
#&交集,|并集
& |
set(a)&set(b)
out:{2,3}
set(a)|set(b)
out: {1,2,3,4}
#差集
set(a) -set(b)
out
1)
set(b) -set(a)
out:(4)
[1,2]>a out: false
--------------------------------------
字典:
a={'name':'yangxi','age':18}
a.keys()
out:dict_keys(['name', 'age'])
但: a.keys()[]会报错
list(a.keys())
out:['name', 'age']
list(a.values())
Out[7]:['yangxi', 18]
------------------
a.items()
Out[9]:
dict_items([('name', 'yangxi'), ('age', 18)])list(a.items())out:[('name', 'yangxi'), ('age', 18)]# 元组不可修改list(a.items())[0][1]out:'yangxi'list(a.items())[0]out
'name', 'yangxi')list(a.items())[0][1]out:'yangxi'a.get('nam',1)获取!单纯查找out1
1
a.get('name',1)
out: 'yangxi'
a.setdefault('sex','female')查找后给赋值
'female'aout;{'name': 'yangxi', 'age': 18, 'sex': 'female'}字典 set{a}$set{b}字典d.get(key,0) #同d[key]d.has_key(key) #有该键值返回true,否则falsed.keys() #返回字典键值列表d.values() #列表的形式返回字典的值,返回时候无顺序d.update(dict2) #增加合并字典d.setdefault('stuid',1123)d.pop(key)d.popitem() #得到一个pair,并从字典中删除它,已空则抛出异常d.clear() #清空字典,同del dictd.copy() #拷贝字典d.cmp(dict1,dict2) #比较字典,(优先级为元素个数,键大小,键值大小)第一个大返回1,小-1,一样0d.items() #变成列表,每个元素为一个元组
作者: 珍妮王小钰 时间: 2019-2-12 15:02
a=10
if a >10:
print('more than 10')
elif a==10:
print('equal to 10')
else :
print('less than 10')
作者: 珍妮王小钰 时间: 2019-2-19 01:37
a=10
if a >10:
print('more than 10')
elif a==10:
print('equal to 10')
else :
print('less than 10')---------------------------
a=10
if a >10:
print('more than 10')
elif a>8:
print('more than 8')
elif a>6 :
print('more than 6')
out: more than 8.
--------------------------------------
if a>10:
print('more than 10')
if a%2==0:
print('ou')
else:
print('no')
else:
print('less than 10')

count=0
while count<10:
print('the num is:',count)
count=count+1#输出然后累加
--->out:
the num is: 0the num is: 1the num is: 2the num is: 3the num is: 4the num is: 5the num is: 6the num is: 7the num is: 8the num is: 9
count=0while count<10:
count=count+1
print('the num is:',count)
--->out:
the num is: 1the num is: 2the num is: 3the num is: 4the num is: 5the num is: 6the num is: 7the num is: 8the num is: 9the num is: 10
冒号: 是属于block控制模块下面的。
count=0while count<10:
count=count+1
print('the num is:',count)
if count==5:
空格break
--->out:
the num is: 1the num is: 2the num is: 3the num is: 4the num is: 5
count=0
while count<10:
count=count+1
print('the num is:',count)
if count==5:continue
the num is: 1the num is: 2the num is: 3the num is: 4the num is: 5the num is: 6the num is: 7the num is: 8the num is: 9the num is: 10

Break是粗暴的终止,而continue是过滤掉中间一步
count=0
while count<10:
count=count+1
if count==5:
continue(5时候跳过了执行下面)
print('the num is:',count)
--->out:
the num is: 1the num is: 2the num is: 3the num is: 4the num is: 6the num is: 7the num is: 8the num is: 9the num is: 10

while里面:count=count+1/2 按1,2 累加
for i in range(1,10):
print(i)
123456789
作者: 珍妮王小钰 时间: 2019-2-19 23:34
for i in range(10):
print(i)
0123456789
for i in range(1,10):
print(i)
123456789

for i in range(5,10): print(i)56789

shift + tab ~~~~~~~~~~~~~~~range(start,stop[, step])
for i in range(5,20,2):
空格print (i)
5791113151719

a=1for i in range(10): a=a+i print(a)1247111622293746
列表循环!a=['a','b','c']for i in a: print(i)abca[0],a[1],a[2]-->out: ('a', 'b', 'c')进阶:拼接a=['a','b','c']b='str:'for i in a: print(b,i)
字典循环!dict={'a':1,'b':3,'c':'abc'}dict.keys()-->out: dict_keys(['a', 'b', 'c'])dict.values()-->out: dict_values([1, 3, 'abc'])for k in dict.keys(): print(k)
abcfor k in dict.values(): print(k)
13abc
for k in dict.items(): print(k)
('a', 1)('b', 3)('c', 'abc')
for k in dict.items(): print(k[0])元组的第一个元素abc
for k in dict.items(): print(k[1])元组的第二个元素13abc------------dict.items()out:dict_items([('a', 1), ('b', 3), ('c', 'abc')])
改进~~for 在python 是多值循环。for k,v in dict.items(): print(k) print(v)out:a1b3cabc再改进~~for k,v in dict.items(): print(k,v)out:a 1b 3c abc
作者: 珍妮王小钰 时间: 2019-2-19 23:58
list=[]
for i in range(1,101):
list.append(i)

改进版!!
list=[i for i in range(1,101)]
list
--------
list=[]
for i in range(1,101):
if i%2== 0:
空格!!list.append(i)
list
------------
list=[i for i in range(1,101)if i%2==0]
list
out:[2,
4, 6, 8,,,,100]list=[i**2 for i in range(1,101)if i%2==0]----------------------------------------------list=['str'+str(i) for i in range(1,101)if i%2==0]list'str2', 'str4', 'str6', 'str8', 'str10', 'str12', 'str14', 'str16', 'str18',,,'str100'
list=['str'+str(i) for i in range(1,101)if (i%2==0)&(i%3==0)]
['str6', 'str12', 'str18', 'str24', 'str30',,,,
作者: 珍妮王小钰 时间: 2019-3-4 13:28
python 变量:
1.python不用事先声明变量,赋值过程中就包含了变量声明和定义过程。
2. 用‘=’赋值,左边是变量名,右边是变量的值。

List []有序的可变(可以修改)集合的容器。
左开右闭:
【0】第一个
【2:5】
【2:】三个开始
元组()
不可变的列表。
字典{}
key- value的集合,无序的容器
print dict_a.keys()
print dict_a.values()
print dict_a.items()
运算符:
+=
-=
*=
/=
%=
**=
//=
----------------------------------------------------------
python 语句:
if
elif a==2:
print "a==2"
else:
print "a !=1 and a!=2"

for 用来遍历容器,或者执行重复性的代码。
遍历容器
list_a= [1,2,"test'"]
for i in list_a:
print i
运行结果
1
2
test

执行重复性代码
for i in range(0,10):
print i
运行结果
0
1
2
....
9

while
a=1
while a!=10:
print a
a+=1

for a in range(1,10):
print a
break 语句:
list_a= [1,2,"test'"]
for i in list_a:
print i
if i ==2:
break
从2跳出循环。
#[0,10]
但不能跳出多个循环:
for i in range(0,10):
print i
for i in range(0,10):
for j in range(0,10)
print i,j
if j==5:
break

continue 直接进行下一次循环。(break是直接跳出整个循环;continue会走下一个循环)
list_a= [1,2,"test'"]
for i in list_a:
print i
if i ==2:
continue
print"~~~~"
作者: 珍妮王小钰 时间: 2019-3-5 05:55
数据结构:
List:
python 内置的一种数据结构;有序;可更改(添加,删除)
声明
game=['dota','dota','lol']
game
['dota','dota','lol']
获取列表长度:
1 len(game)
2 3
获取元素:
game[0]
'dota'
game[2]
'lol'
增删查改

增加元素
末尾追加
game.append('wow')
game[3]
'wow'
game
['dota','dota','lol','wow']
删除元素
删除末尾的元素
game.pop()
不写就默认删除最后一个。
‘wow'
game
['dota','dota','lol']
改元素
game[0]='dota2'
game
['dota2','dota','lol']

tuple:
python 内置的一种数据结构;有序;不可更改(安全);在赋值的时候决定所有元素
声明
game=('dota','war3','lol')
game
('dota','war3','lol')
声明完后不用更改,安全
获取列表长度:
len(game)
3
获取元素:
game[0]
'dota'
game[2]
'lol'

dict:
python内置的一种数据结构;无序;可更改
类似于C++语言的map,存键值对,有很快的查找速度。比如根据身份证号查找某个热难道名字,根据学号查找学生成绩单。用List遍历也可以得到结果,但是太慢了,list就好像你在小区找人,一家家敲门。dict就好像你直接按照地址找。
dict用空间换时间,占内存大,但查找插入速度很快不会随着元素数量增加而增加。list是时间换空间的例子。不会占用大量内存,但随着元素数量增加,查找时间会变很长。
声明
name={1:'alan', 2:'bob', 3:'lucy'}
查找
name[1]
'alan'
name[2]
'bob'
为了避免出现报错情况我们一般要事先判断一下这个key是否在dict里面:
5 in name
false.
2 in name
true
也可以用get方法取,如果key不存在,会返回None或者自己定义的默认值。
name.get(5)
name.get(5,'default')
"default"没找到
增加
name[5]='sam"
name
{1:'alan', 2:'bob', 3:'lucy',5:'sam'}
删除
name.pop(1)
’alan'
name
{ 2:'bob', 3:'lucy'}
name.pop(5)
‘sam'
name
{1:'alan', 2:'bob', 3:'lucy'}
len(name)
3(三个键值对)
name.key()
[1,2,3]
name.values()
['alan', 'bob','lucy]
name.items()
[(1,'alan'),(2,"bob'),(3,“lucy')]
作者: 珍妮王小钰 时间: 2019-3-6 05:52
set:
python内置数据结构;无序;可更改
set可以视为没有value的dict,只存key,一般用做去重或者集合求交,求并等。
声明
girls_1=set(['lucy','lily'])
girls_2=set(['lily','anna'])
求并,交
girls_1&girls_2
set(["lily'])
girls_1|girls_2
set(['lily','lucy','anna']
增加元素
girls_1.add('marry')
girls_1
set(['marry','lily','lucy'])
删除元素
girls_1.remove('lucy']
girls_1
set(['marry','lily'])

python 函数
函数是可重复调用的代码短,能提高代码的复用率。
定义格式
#无参数
def print_hello():
print"hello"
print_hello()--hello
#带参数
def print_str(s)
print s
return s*2
print_str("fuck")
--fuckfuck
#带默认参数
def print_default(s='hello'):
print s
print_default()
print_default("default")
-hello
-default
#不定长参数
def print_args(s,*arg):
print s
for a in arg:
print a
return
print_args("hello")
print_args("hello","world","1")
*"world","1" 存放在arg里。
-hello
-hello
world
1
#参数次序可以变
def print_two(a,b):
print a,b
print_two(a="a", b="b")
print_two(b="b",a ="a"
a b
a b
作者: 珍妮王小钰 时间: 2019-3-17 07:20
标题: SDE打基础~
https://www.zhihu.com/question/57449577 笨办法才是好方法。每个代码敲三遍,第一步抄;第二遍保留框架 注释自己默写,第三从头到尾白板一遍。 |把学到的整理成博客。
https://zhuanlan.zhihu.com/gaihangcs 改行CS
G: 基本功,综合能力(灵活)
eX: 一个笔记本电脑4g 1TB data, 怎么找到所有的数据??给你一万台1g XXXdata(用mapreduce 找到data所有pair)算法+系统设计。 考problem solving的能力。two sum: 30~35 女生,口红裙子 找ID
---------------------------------
part 1 系统CS理论知识
part2 扎实的一线公司coding skills
part3 工业界项目-> Outstanding Resume
New: 第四个月,三个工业界大项目
part4. 面试软实力
part5. Referral +职业发展 平台。
作者: 珍妮王小钰 时间: 2019-3-18 03:47
简介面向对象是我们经常能听到的术语,即class,类。事实上,主角是两个,一个是类,一个是类实例。人类,是一个类,我们每一个人是一个人类的实例。而类之间又有一些关系,例如,我们既是人类,也是动物,更细化来讲,我们是哺乳类动物,灵长类,类似于集合的概念,哺乳动物属于动物,而在面向对象中我们通常称哺乳动物是动物的子类。而对于动物这个类来说,会自带一些属性,例如:年龄、体重。也会有一些方法:生殖、呼吸。而不同种类的动物(即动物类的各种子类)可能会有不同的属性或方法,像胎生、卵生,像鸟类的飞行的方法和豹子奔跑的方法。
定义用关键字class去定义一个类,如果没有指定父类,默认继承object类。
- class Human(object):
- pass
这样,我们定义个了一个Human,人类。
类属性- class Human(object):
- taisheng = True
为什么要叫类属性呢,因为这个属性是和类绑定的,并不是和实例绑定的。胎生这个属性是全人类共有的,并不是某个人特殊拥有的属性。
实例属性- class Human(object):
- def __init__(self, name):# 构造函数。用来作为这个实例的初始化。
- self.name = name
- human_a = Human("alan")
我们首先实例化了一个人类human_a,然后给这个人类设置了一个实例属性name,name这个属性独立于其他的人类,是和实例绑定的,所以叫实例属性。#实例属性是针对某个实例的。 例属性可以在实例创建后任意时间设置。
类方法- class Human(object):
- def __init__(self, name):
- self.name = name
- def walk(self):
- print self.name + " is walking"
- human_a = Human("alan")
- human_a.walk()
运行结果:
类的方法可以看做是一种类属性,而传入的第一个参数self,表示调用这个类方法的实例。像上面的例子,human_a调用了walk这个类方法,human_a的名字是alan,所以运行的结果就是alan is walking。
访问控制从上面的例子来看,我们可以在外部随意更改name这个属性,如果不想让外部直接访问到,则在属性名字前加两个下划线__name,这样从外部就无法直接访问了。如果还是想访问,可以再加个get的接口。
- class Human(object):
- def __init__(self, name):
- self.__name = name
- def walk(self):
- print self.name + " is walking"
- def get_name(self):
- return self.__name
- human_a = Human("alan")
- print human_a.get_name()
- print human_a.__name
如果还是想更改__name字段,可以再加上一个set接口
- class Human(object):
- def __init__(self, name):
- self.__name = name
- def walk(self):
- print self.name + " is walking"
- def get_name(self):
- return self.__name
- def set_name(self, name):
- self.__name = name
- human_a = Human("alan")
- print human_a.set_name("bob")
可能有人会有疑问,为何要这么“画蛇添足”呢?其不然,这样会增强代码的健壮性,直接暴漏属性可能会带来意想不到的后果,通过接口的方式可以加以控制,例如,我们可以通过set接口去限定name的长度。
- class Human(object):
- def __init__(self, name):
- self.__name = name
- def walk(self):
- print self.name + " is walking"
- def get_name(self):
- return self.__name
- def set_name(self, name):
- if len(name) <= 10:
- self.__name = name
- human_a = Human("alan")
- print human_a.set_name("bob")
这样就不会出现name过长的情况。
继承最开始的简介里说到,哺乳动物是动物的一种,用面向对象的属于来说,哺乳动物是动物的子类,子类拥有父类的属性、方法,即继承。同时又可以拥有父类没有的属性和方法,即多态。
还是以人类为例,通常来说,人类又可以分为男人和女人(当然也有别的,23333)
- class Human(object):
- def __init__(self, name):# 构造函数。用来作为这个实例的初始化。
- self.name = name
- ------------------------------------
- class Man(Human):
- def __init__(self, name, has_wife):
- self.__name = name
- self.__has_wife = has_wife
来,我们看下这个男人,多了一个新的属性,__has_wife(是否已婚)。我们写到了Man的构造函数里。其实通常并不这么写构造函数,假如Human里有很多属性、很多初始化步骤,我们Man继承的时候难不成要复制粘贴一遍Human的构造函数?当然不是啦,通常会这么写。
- class Man(Human):
- def __init__(self, name, has_wife):
- super(Man, self).__init__(name)
- self.__has_wife = has_wife
super(Man, self).__init__(name)等价于调用了父类Human的构造函数,就不用再复制粘贴一遍了。
既然有男人,那就再来个女人吧。
- class Woman(Human):
- def __init__(self, name, has_husband):
- super(Woman, self).__init__(name)
- self.__has_husband = has_husband
我们都道,男人和女人是不一样的,通常男人都自带抽烟、喝酒、烫头,啊。。。并没有烫头。
- class Man(Human):
- def __init__(self, name, has_husband):
- super(Man, self).__init__(name)
- self.__has_husband = has_husband
- def smoke(self):
- print "A man maybe smoke"
- def drink(self):
- print "A man maybe drink"
当然,女人也自带逛街、化妆等天赋技能。
- class Woman(Human):
- def __init__(self, name, has_husband):
- super(Woman, self).__init__(name)
- self.__has_husband = has_husband
- def shopping(self):
- print "A woman always go shopping"
- def make_up(self):
- print "A woman always make up"
好了,观众朋友们,有没有感觉到这种继承的优越性。可以很清晰地看到,男人和女人都有一些相同的属性,也有一些各自不同的方法。如果哪天人类有了别的方法、属性,直接在Human类更改,男人和女人也会自动继承。如果想再设计一个双性人这个类,那直接从Human继承就可以了,对男人和女人不会有任何影响。这就是面向对象的优越性啊!
作者: 珍妮王小钰 时间: 2019-3-28 07:30
del del(x[1])
The ; sign is used to place commands on the same line.
# Same line
command1; command2
# Separate lines
command1
command2
although you've changed areas_copy, the change also takes effect in the areas list. That's because areas and areas_copy point to the same list.If you want to prevent changes in areas_copy from also taking effect in areas, you'll have to do a more explicit copy of the areas list. You can do this with list() or by using [:]# Create list areas
areas = [11.25, 18.0, 20.0, 10.75, 9.50]
# Create areas_copy
areas_copy = list(areas)
# Change areas_copy
areas_copy[0] = 5.0
# Print areas
print(areas)
作者: 珍妮王小钰 时间: 2019-3-29 02:16
# string to experiment with: place
place = "poolhouse"
# Use upper() on place: place_up
place_up = place.upper()
# Print out place and place_up
print(place)
print(place_up)
# Print out the number of o's in place
print(place.count('o'))
欢迎光临 ChaseDream (https://forum.chasedream.com/) |
Powered by Discuz! X3.3 |